Systems and methods for adaptive data storage

ABSTRACT

A storage module is configured to store data segments, such as error-correcting code (ECC) codewords, within an array comprising two or more solid-state storage elements. The data segments may be arranged in a horizontal arrangement, a vertical arrangement, a hybrid channel arrangement, and/or vertical stripe arrangement within the array. The data arrangement may determine input/output performance characteristics. An optimal adaptive data storage configuration may be based on read and/or write patterns of storage clients, read time, stream time, and so on. Data of failed storage elements may be reconstructed by use of parity data and/or other ECC codewords stored within the array.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.13/784,705, entitled “SYSTEMS AND METHODS FOR ADAPTIVE DATA STORAGE” andfiled on Mar. 4, 2013, which claims priority to U.S. Provisional PatentApplication Ser. No. 61/606,253, entitled, “Adaptive Data Arrangement,”filed Mar. 2, 2012 for David Flynn et al. and to U.S. Provisional PatentApplication Ser. No. 61/606,755, entitled, “Adaptive Data Arrangement,”filed Mar. 5, 2012, for David Flynn et al., and is acontinuation-in-part of, and claims priority to, U.S. patent applicationSer. No. 13/296,834, entitled, “Apparatus, System, and Method forStorage Space Recovery in Solid-State Storage,” filed Nov. 15, 2011, forDavid Flynn et al., which is a continuation-in-part of, and claimspriority to, U.S. patent application Ser. No. 11/952,101 entitled“Apparatus, System, and Method for Storage Space Recovery in Solid-StateStorage,” filed on Dec. 6, 2007 for David Flynn, et al., which claimspriority to U.S. Provisional Patent Application Ser. No. 60/873,111entitled “Elemental Blade System” filed on Dec. 6, 2006 for David Flynn,et al., and to U.S. Provisional Patent Application Ser. No. 60/974,470entitled “Apparatus, System, and Method for Object-Oriented Solid-StateStorage” filed on Sep. 22, 2007 for David Flynn, et al., all of whichare incorporated herein by reference in their entirety.

TECHNICAL FIELD

This disclosure relates to data storage and, in particular, to datalayout and/or arrangement on a solid-state storage medium.

BACKGROUND

Solid-state storage devices may have different read time Tr, stream timeTs, and other characteristics, which may affect device performance indifferent data layout configurations. Usage characteristics, such as thesize of typical read and/or write operations may also impact deviceperformance. What is needed is a storage module capable of adaptive datalayout to enable the solid-state storage device to provide improvedperformance in accordance with different storage medium characteristicsand/or device usage patterns.

SUMMARY

Disclosed herein are embodiments of an apparatus for adaptive datastorage. The apparatus may comprise a storage module configured tomanage storage operations on a plurality of solid-state storageelements, an error-correcting code (ECC) write module configured togenerate an ECC codeword comprising data for storage on the solid-statestorage elements, and an adaptive write module configured to storeportions of the ECC codeword on two or more of the solid-state storageelements. The ECC write module may be configured to generate a first setof ECC codewords comprising data of a first storage request and a secondset of ECC codewords comprising data of a second storage request. Theadaptive write module may be configured to store the first set of ECCcodewords in a first set of one or more solid-state storage elements andto store the second set of ECC codewords in a second, different set ofone or more solid-state storage elements.

The apparatus may further comprise an adaptive read module configured toread ECC codewords comprising the data of the first storage request fromthe first set of solid-state storage elements and to read ECC codewordscomprising the data of the second storage request from the second set ofsolid-state storage elements in a single read operation.

In some embodiments, the adaptive write module may be configured todivide the plurality of solid-state storage elements into a plurality ofindependent channels, each independent channel comprising a respectivesubset of solid-state storage elements. The adaptive write module may beconfigured to store ECC codewords corresponding to respective storagerequests within respective independent channels.

The apparatus may comprise an adaptive profiling module configured todetermine an optimal independent channel configuration based on one ormore of a read time of the solid-state storage elements, a stream timeof ECC codewords, and/or profiling data pertaining to storage operationsperformed by the storage module.

In some embodiments, the apparatus further comprises a relational moduleconfigured to mark the ECC codeword with relational information derivedfrom a logical identifier corresponding to the data of the ECC codeword,and an ECC decode module configured to validate the mark.

Disclosed here are embodiments of an apparatus for adaptive storagecomprising, a storage module configured to manage storage operations ona solid-state storage array comprising a plurality of columns, eachcolumn comprising a respective solid-state storage element, an ECC writemodule configured to generate ECC codewords comprising data segments forstorage on the solid-state storage array, and an adaptive write moduleconfigured to format the ECC codewords into vertical stripes, whereinthe vertical stripes are configured to arrange data of the ECC codewordswithin respective columns of the solid-state storage array, wherein twoor more ECC codewords comprising one of the data segments are storedwithin two or more different columns.

The apparatus may further comprise an adaptive read module configured toidentify two or more columns comprising ECC codewords comprising arequested data segment, and to read the ECC codewords comprising therequested data segment from the two or more columns in parallel.

In some embodiments, the apparatus further comprises a read sequencemodule configured to reorder the ECC codewords in accordance with anorder of the requested data segment and the vertical stripe arrangementof the ECC codewords within the solid-state storage array. The apparatusmay also include an adaptive schedule module configured to combine twoor more read operations into a combined read operation, the two or moreread operations corresponding to ECC codewords stored within differentsets of columns of the solid-state storage array. The apparatus mayinclude an ordered queue of storage requests, wherein the adaptiveschedule module is configured to combine two or more read operationswithin the ordered queue into the combined read operation, whereincombining the two or more storage requests comprises modifying an orderof the storage requests within the ordered queue. The combined readoperation may comprise providing different addressing information to thedifferent sets of columns of the solid-state storage array.

The apparatus may further include an ECC read module configured todetect an uncorrectable ECC codeword in response to a first readoperation, and a data recovery module configured to recover theuncorrectable ECC codeword by reading other ECC codewords within thevertical stripe with the uncorrectable ECC codeword in a second readoperation, decoding the other ECC codewords, and reconstructing theuncorrectable ECC codeword using the decoded ECC codewords and paritydata of the vertical stripe.

Disclosed herein are embodiments of an apparatus, comprising a writemodule configured to generate data rows for storage within columns of asolid-state storage array, a parity module configured to generaterespective parity data for each of the data rows, and an adaptive writemodule configured to stream the data rows and the corresponding paritydata to respective columns of the solid-state storage array in parallel.

The apparatus may include an adaptive write module configured to arrangeECC codewords for storage within respective subsets of the columns ofthe solid-state storage array, wherein each of the data rows comprisesdata of two or more different ECC codewords. The adaptive write modulemay be configured to store the two or more different ECC codewordswithin respective subsets of columns of the solid-state storage array bystreaming a plurality of data rows and corresponding parity data to therespective columns of the solid-state storage array, wherein each datarow comprises data of each of the two or more different ECC codewords.In some embodiments, each data row comprises a byte of each of the twoor more different ECC codewords and a corresponding parity byte.

The apparatus may further comprise a data reconstruction moduleconfigured to reconstruct an uncorrectable ECC codeword of the two ormore ECC codewords by accessing data rows and corresponding parity datacomprising the two or more ECC codewords from the solid-state storagearray, correcting other ECC codewords within the accessed data rows, andreconstructing the uncorrectable ECC codeword using the corrected ECCcodewords and the corresponding parity data. Reconstructing theuncorrectable ECC codeword may comprise a byte-wise parity substitutionusing the corrected ECC codewords and the corresponding parity data.

Disclosed herein are embodiments of a method for adaptive storage. Thedisclosed methods may comprise one or more machine-executable operationsand/or steps. The disclosed operations and/or steps may be embodied asprogram code stored on a computer readable storage medium. Accordingly,embodiments of the methods disclosed herein may be embodied as acomputer program product comprising a computer readable storage mediumstoring computer usable program code executable to perform one or moremethod operations and/or steps.

The disclosed method may comprise acquiring profiling data pertaining tostorage operations performed on a solid-state storage array comprising aplurality of independent data columns, each independent data columncomprising a solid-state storage element, determining performancecharacteristics corresponding to a plurality of different adaptive datastorage configurations, wherein each of the adaptive data storageconfigurations corresponds to storage of data segments in one of ahorizontal configuration, a vertical configuration, a hybridconfiguration, and a vertical stripe configuration, and determining anoptimal adaptive data storage configuration based on the determinedperformance characteristics. The horizontal configuration may comprisestoring ECC codewords within each of the independent data columns. Thevertical configuration may comprise storing ECC codewords withinrespective independent data columns. The hybrid configuration maycomprise storing ECC codewords within respective subsets of theindependent data columns. The vertical stripe configuration may comprisestoring ECC codewords within respective independent data columns at avertical stripe depth. The vertical stripe depth may be less than a pagedepth of the solid-state storage elements.

Disclosed herein is a method for adaptive storage comprising identifyingan uncorrectable ECC codeword stored within one of a plurality ofsolid-state storage elements, correcting one or more ECC codewordsstored within others of the plurality of solid-state storage elements,accessing parity data corresponding to the uncorrectable ECC codewordand corrected ECC codewords, and rebuilding data of the uncorrectableECC codeword through parity substitution operations comprising thecorrected ECC codewords and the accessed parity data. The method mayfurther comprise arranging ECC codewords for storage within respectiveindependent channels, each independent channel comprising one or more ofthe solid-state storage elements.

In some embodiments, the method includes buffering ECC codewords forstorage within respective solid-state storage elements, and streamingdata rows to the solid-state storage elements, each data row comprisinga byte of a respective ECC codeword for storage on a respective one ofthe solid-state storage elements and a corresponding parity byte.Rebuilding data of the uncorrectable ECC codeword may comprise accessingdata rows stored within the solid-state storage elements and performingbyte-wise parity substitution operations to rebuild the uncorrectableECC codeword.

Disclosed herein are methods for adaptive storage comprising,determining a storage location of a plurality of ECC codewordscomprising requested data, wherein the ECC codewords are stored within agroup of two or more different solid-state storage elements of asolid-state storage array, identifying ECC codewords comprising data ofone or more other requests stored within different groups of solid-statestorage elements of the solid-state storage array, scheduling a readoperation on the solid-state storage array configured to read the ECCcodewords of the requested data and ECC codewords comprising data of theone or more other requests in a single read operation on the solid-statestorage array.

The method may further include queuing storage requests in an orderedrequest buffer, and determining a storage location of ECC codewords ofone or more other requests in the request buffer. Scheduling the readoperation may comprise reordering one or more storage requests in theordered request buffer. Scheduling the read operation may furtherinclude providing different addressing information for two or more ofthe solid-state storage elements. In some embodiments, the methodfurther comprises reordering contents of a read buffer to reconstruct adata packet stored within the plurality of ECC codewords comprising therequested data.

Disclosed herein are embodiments of a system for adaptive storage,comprising means for generating ECC codewords comprising data segmentsfor storage on one or more solid-state storage elements, wherein eachsolid-state storage elements are communicatively coupled to a storagecontroller by a bus, means for arranging the ECC codewords for storagein a vertical stripe configuration, wherein the vertical stripeconfiguration comprises arranging each ECC codeword for storage within arespective one of the solid-state storage elements, and wherein ECCcodewords comprising a data segment are arranged for storage on two ormore different solid-state storage elements, and means for storing thearranged ECC codewords on the solid-state storage elements. The verticalstripe configuration may comprise arranging ECC codewords within thesolid-state storage elements at a vertical stripe depth, wherein thevertical stripe depth is less than a page size of the solid-statestorage elements and is an integral factor of a size of the ECCcodewords.

In some embodiments, the means for arranging the ECC codewords forstorage in the vertical stripe configuration comprises means forstreaming data rows of the arranged ECC codewords to respective programbuffers of the solid-state storage array and means for calculatingparity data corresponding to each of the data rows.

The system may further include means for reconstructing a corrupt ECCcodeword, comprising

means for reading one or more other ECC codewords stored within avertical stripe comprising the corrupt ECC codeword, means forcorrecting the one or more other ECC codewords, and means forreconstructing the corrupt ECC codeword using the corrected one or moreother ECC codewords and parity data corresponding to data rows of thevertical stripe.

In some embodiments, the system may further comprise means for adaptivescheduling, including means for identifying respective sets of one ormore solid-state storage elements comprising data of each of a pluralityof queued read requests, and means for determining a read operationconfigured to perform two or more of the queued read requests in asingle read operation on the plurality of solid-state storage elements.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of one embodiment of a system for adaptivestorage;

FIG. 2 is a block diagram of one embodiment of a storage module;

FIG. 3 depicts one embodiment of a packet;

FIG. 4 depicts one embodiment of ECC codewords comprising one or moredata segments;

FIG. 5A is a block diagram depicting one embodiment of a solid-statestorage array;

FIG. 5B is a block diagram depicting another embodiment of a solid-statestorage array;

FIG. 5C is a block diagram depicting another embodiment of banks ofsolid-state storage arrays;

FIG. 5D depicts one embodiment of sequential bank interleave;

FIG. 5E depicts another embodiment of sequential bank interleave;

FIG. 6A is a block diagram of one embodiment of a system for adaptivedata storage;

FIG. 6B depicts one embodiment of horizontal, adaptive data storage;

FIG. 6C is a block diagram of another embodiment of a system foradaptive data storage;

FIG. 6D depicts one embodiment of vertical, adaptive data storage;

FIG. 6E is a block diagram of another embodiment of a system foradaptive data storage;

FIG. 6F depicts another embodiment of adaptive data storage on asolid-state storage array;

FIG. 6G depicts one embodiment of a vertical stripe configuration on asolid-state storage array;

FIG. 6H depicts another embodiment of a vertical stripe configuration ona solid-state storage array;

FIG. 6I is a block diagram of another embodiment of a system foradaptive data storage;

FIG. 6J depicts another embodiment of a vertical stripe configuration ona solid-state storage array;

FIG. 6K is a block diagram of another embodiment of a system foradaptive data storage;

FIG. 6L is a block diagram of another embodiment of a system foradaptive data storage;

FIG. 7 depicts one embodiment of a system for adaptive scheduling;

FIG. 8 depicts one embodiment of a system for adaptive datareconstruction;

FIG. 9 is a flow diagram of one embodiment of a method for adaptivestorage on a solid-state storage array;

FIG. 10 is a flow diagram of another embodiment of a method for adaptivestorage on a solid-state storage array;

FIG. 11 is a flow diagram of another embodiment of a method for adaptivestorage on a solid-state storage array;

FIG. 12 is a flow diagram of one embodiment of a method for adaptivescheduling of storage requests;

FIG. 13 is a flow diagram of one embodiment of a method for adaptivedata recovery; and

FIG. 14 is a flow diagram of one embodiment of a method for determiningan adaptive data storage configuration.

DETAILED DESCRIPTION

FIG. 1 is a block diagram of one embodiment of a system 100 comprising astorage module 130 configured to manage a solid-state storage medium110. The storage module 130 may comprise an adaptive storage module 113,a logical-to-physical translation layer 132, storage metadata module134, log storage module 137, groomer module 138, a profiling module, anda data reconstruction module 170. The storage module 130 may comprisesoftware and/or hardware components. Portions of the storage module 130(and/or the modules and/or components thereof) may be implemented usingsoftware modules, such as drivers, services, and/or the like. Otherportions of the storage module 130 (and/or the modules and/or componentsthereof) may be implemented using hardware resources, such as FPGAs,processors, ASICS, hardware controllers, storage controllers, and thelike.

The solid-state storage medium 110 may comprise a non-volatile,solid-state storage medium, such as flash memory, nano random accessmemory (nano RAM or NRAM), nanocrystal wire-based memory, silicon-oxidebased sub-10 nanometer process memory, graphene memory,Silicon-Oxide-Nitride-Oxide-Silicon (SONOS), Resistive Random-AccessMemory (RRAM), Programmable Metallization Cell (PMC),Conductive-Bridging RAM (CBRAM), Magneto-Resistive RAM (MRAM), DynamicRAM (DRAM), Phase change RAM (PRAM), or the like. The solid-statestorage medium 110 may comprise a plurality of physical storage units(e.g., storage cells) configured for persistent data storage. Thephysical storage units may be arranged in groups, such as pages, whichmay be partitioned into storage divisions, such as erase blocks. Thesolid-state storage medium 110 may comprise pages of any suitable size.The page size of a solid-state storage medium 110 may range from 512 bto 32 kb.

The adaptive storage module 113 may be configured to write data toand/or read data from the solid-state storage medium 110 via a bus 127.The adaptive storage module 113 may comprise one or more hardwarecomponents, such as bus controllers, DMA controllers, storagecontrollers, storage media controllers, and the like. The adaptivestorage module 113 may further comprise firmware, software modules,drivers, interface modules, and/or and the like.

The bus 127 may comprise a storage I/O bus for communicating datato/from the solid-state storage medium 110, and may further comprise acontrol I/O bus for communicating addressing and other command andcontrol information to the solid-state storage medium 110.

The storage module 130 may comprise and/or be implemented on a computingdevice 101. In some embodiments, portions of the storage module 130 maybe internal to the computing device 101; for example, portions of thestorage module 130 and/or solid-state storage medium 110 may beconnected using a system bus, such as a peripheral componentinterconnect express (PCI-e) bus, a Serial Advanced TechnologyAttachment (serial ATA) bus, or the like. The disclosure is not limitedin this regard; in some embodiments, components of the storage module130 may be external to the computing device 101, and may be connectedvia a universal serial bus (USB) connection, an Institute of Electricaland Electronics Engineers (IEEE) 1394 bus (FireWire), an external PCIbus, Infiniband, or the like.

The computing device 101 may comprise a processor 103, volatile memory106, and/or persistent storage 105. The processor 103 may comprise oneor more general and/or special purpose processing elements. Theprocessor 103 may be configured to execute instructions loaded into thevolatile memory 106 from the persistent storage 105. Portions of one ormore of the modules of the storage module 130 may be embodied asmachine-readable instructions stored on the persistent storage 105. Theinstructions may be configured for execution by the processor 103 toimplement one or more of the modules and/or methods described herein.

One or more storage clients 104 may access storage services provided bythe storage module 130 through a storage interface 131. The storageinterface 131 may comprise a block device interface, a virtualizedstorage interface, an object storage interface, a database storageinterface, and/or other suitable interface and/or ApplicationProgramming Interface (API). The storage module 130 may further comprisea logical-to-physical translation layer 132 to map and/or associateidentifiers of the storage client 104 with physical storage locations(e.g., physical addresses) on the solid-state storage medium 110. Thelogical-to-physical translation layer 132 may provide for “any-to-any”mappings between logical identifiers and physical storage locations,such that data may be written and/or updated “out-of-place” on thesolid-state storage medium 110. As used herein, a physical addressrefers to an address (or other reference) capable of referencing aparticular storage location on the solid-state storage medium 110.Accordingly, a physical address may be a “media address.”

The storage module 130 may comprise a storage metadata module 134configured to maintain storage metadata 135 pertaining to storageoperations performed on the solid-state storage medium 110. The storagemetadata 135 may include, but is not limited to: an index comprisingany-to-any mappings between logical identifiers of a logical addressspace and physical storage locations on the solid-state storage medium110, a reverse index pertaining to the contents of the solid-statestorage medium 110, one or more validity bitmaps, reliability testingand/or status metadata, status information, such as error rate,retirement status, and so on. Portions of the metadata 135 may be storedon a volatile memory 106. Alternatively, or in addition, portions of themetadata 135 may be periodically stored on a persistent storage medium,such as the persistent storage 105, solid-state storage medium 110, orthe like.

The storage module 130 may comprise a request buffer 136 configured tobuffer storage requests received via the storage interface 131. Therequest buffer 136 may comprise an ordered buffer, such as afirst-in-first-out (FIFO) or the like. The request buffer 136 may,therefore, be configured to maintain the order of incoming storagerequests. As used herein, a storage request refers to one or more of arequest to store, write, overwrite, modify, cache, delete, erase, read,and/or otherwise manage data by use of the storage module 130. Thestorage module 130 may be configured to service the storage requests inthe request buffer 136. The storage module 130 may be configured toservice the storage requests in the order they were received.Alternatively, the storage module 130 may be configured to reorder thestorage requests to improve throughput and/or efficiency. The storagemodule 130 may be configured to reorder the storage requests to avoiddata hazards, such as read-before-write, write-before-read, and so on.

The storage module 130 may comprise a log storage module 137 configuredto store data in a “contextual format” on the solid-state storage medium110. As used herein, a “contextual format” refers to a data format inwhich a logical interface of a data segment is associated with the datasegment on the solid-state storage medium 110. For example, a contextualformat may comprise a packet format that includes a header indicatingone or more logical identifiers of a data segment, or the like. Thecontextual format may be used to reconstruct the mappings of thelogical-to-physical translation layer 132 (and/or storage metadata 135),such as any-to-any mappings between logical identifiers and physicalstorage locations, reverse index metadata, and the like.

In some embodiments, the storage module 130 comprises a groomer module138 configured to perform grooming operations on the solid-state storagemedium 110. Grooming operations may include, but are not limited to:reclaiming storage resources, erasure, wear leveling, refreshing datastored on the solid-state storage medium 110, and so on. The groomermodule 138 may operate outside of the path for servicing other,higher-priority storage operations and/or requests. Therefore, thegroomer module 138 may operate as an autonomous, background process,which may be suspended and/or deferred while other storage operationsare in process. Alternatively, the groomer module 138 may operate in theforeground while other storage operations are being serviced. Thegroomer 138 may wear-level the non-volatile storage medium 110, suchthat data is systematically spread throughout different storagelocations, which may improve performance, data reliability, and avoidoveruse and/or underuse of particular storage locations, therebylengthening the useful life of the solid-state storage medium 110.Grooming an erase block (or logical erase block) may comprise relocatingvalid data (if any) to other storage locations, erasing the erase block,and/or initializing the erase block for storage operations (e.g.,marking the erase block with a sequence indicator, sequence number,timestamp, or the like). The groomer module 138 may operate within adriver of the storage module 130. Alternatively, or in addition,portions of the groomer module 138 may be implemented on the adaptivestorage module 113 (e.g., as hardware components, firmware, programmablehardware components, or the like).

In some embodiments, the solid-state storage medium 110 may comprise oneor more arrays 115 of solid-state storage elements 116A-Y. As usedherein, a solid-state storage array (or array) refers to a set of two ormore independent columns 118. A column 118 may comprise a solid-statestorage element 116A-Y that is communicatively coupled to the storagemodule 130 in parallel by the adaptive storage module 113 using, interalia, the bus 127. Rows 117 of the array 115 may comprise physicalstorage units of the respective columns 118 (solid-state storageelements 116A-Y). As used herein, a solid-state storage element 116A-Yincludes, but is not limited to solid-state storage resources embodiedas: a package, a chip, die, plane, printed circuit board, and/or thelike. The solid-state storage elements 116A-Y comprising the array 115may be capable independent operation. Accordingly, a first one of thesolid-state storage elements 116A may be capable of performing a firststorage operation while a second solid-state storage element 116Bperforms a different storage operation. For example, the solid-statestorage element 116A may be configured to read data at a first physicaladdress, while another solid-state storage element 116B reads data at adifferent physical address.

A solid-state storage array 115 may also be referred to as a logicalstorage element (LSE). As disclosed in further detail below, an array orlogical storage element 115 may comprise logical storage units (rows117). As used herein, a “logical storage unit” or row 117 refers to alogical construct combining two or more physical storage units, eachphysical storage unit on a respective column 118 of the array 115. Alogical erase block refers to a set of two or more physical eraseblocks, a logical page refers to a set of two or more pages, and so on.In some embodiments a logical erase block may comprise erase blockswithin respective logical storage elements 115 and/or banks.Alternatively, a logical erase block may comprise erase blocks within aplurality of different arrays 115 and/or may span multiple banks ofsolid-state storage elements.

The storage module 130 may further comprise an adaptive storage module113 configured arrange data for storage on the solid-state storage array115 according to an adaptive data layout. As used herein, an adaptivedata layout refers to the layout of storage data segments withindifferent portions of the solid-state storage array 115. As used herein,a data segment refers to a quantum of structured or unstructured data; adata segment may, therefore, include, but is not limited to: datapertaining to a storage request, data corresponding to one or morelogical identifiers, one or more data blocks, a data structure, such asa data packet, container, or the like, a data set, such as a data range,extent, or the like, an ECC codeword, such as an ECC syndrome, an ECCsymbol, an ECC chunk, or the like, unstructured data, structured data, adata record, or the like.

The adaptive storage module 113 may be configured to store data in ahorizontal layout, which may comprise storing data segments horizontallywithin rows 117 of the array (e.g., across a plurality of thesolid-state storage elements 116A-Y of the array 115). A vertical layoutmay comprise storing data segments within respective columns 118 of thearray 115 (e.g., within a single solid-state storage elements 116A-Y).Other layouts may comprise storing data on subsets of the solid-statestorage elements 116A-Y (e.g., sets of two, four, or more solid-statestorage elements 116A-Y). The storage module 130 may comprise anadaptive storage profiling module 160 configured to determine an optimaldata layout for the array 115 based on one or more of data read latency,stream latency, data access patterns, profiling information, desireddata recovery characteristics, usage and/or the like.

In some embodiments, the storage module 130 further comprises a datarecovery module 170. The data recovery module 170 may be configured torecover data stored on the solid-storage storage medium 110. The storagemodule 130 may be configured to generate error recovery data, such asECC data, parity data, and/or the like. The error recovery data may bestored on the solid-state storage medium 110. The ECC data may be usedto detect and/or correct errors in data read from the array 115. Datacomprising uncorrectable errors may be reconstructed by use of paritydata. Uncorrectable errors may result from failure of a portion of aparticular column 118 (e.g., failure of an erase block, plane, die, orother portion of a particular solid-state storage element 116A-Y). Asdisclosed in further detail herein, data corresponding to the failedcolumn 118 may be reconstructed by use of data stored on othersolid-state storage elements 116A-Y. In some embodiments, reconstructingdata of a failed solid-state storage element 116A-Y may comprise readingone or more ECC codewords stored on other columns 118 of the array 115,correcting errors within the one or more other ECC codewords (e.g.,decoding the ECC codewords), and using the corrected ECC codewords toreconstruct data of the failed element 116A-Y. The data reconstructionmodule 170 may comprise a parity substitution module 172 configured toreconstruct data of a failed column by use of error-corrected ECCcodewords and/or parity data stored within the array 115. In someembodiments, data of the failed column may be reconstructed withoutdecoding and/or correcting the other ECC codewords; if the other columns118 have low error rates (and/or low levels of wear), the reconstructionmodule 170 may be configured to perform the parity substitutionoperations without first decoding and/or correcting the other ECCcodewords.

FIG. 2 is a block of one embodiment of a storage module 130 configuredto manage data storage operations on a solid-state storage medium 110.In some embodiments, the solid-state storage medium 110 may comprise oneor more independent banks 119A-N of solid-state storage arrays 115A-N.As disclosed above, each array 115A-N may comprise a plurality ofsolid-state storage elements communicatively coupled to the adaptivestorage module 113 in parallel via a bus 127.

The adaptive storage module 113 may comprise a request module 231configured to receive storage requests from the storage module 130and/or other storage clients 104. The request module 231 may beconfigured to perform storage operations on the solid-state storagemedium 110 in response to the requests, which may comprise transferringdata to/from the storage module 130 and/or storage clients 104.Accordingly, the request module 231 may comprise one or more directmemory access (DMA) modules, remote DMA modules, bus controllers,bridges, buffers, and the like.

The adaptive storage module 113 may comprise a write module 240configured to process data for storage on the solid-state storage medium110. In some embodiments, the write module 240 comprises one or moremodules configured to process and/or format data for storage on thesolid-state storage medium 110, which may include, but are not limitedto: a packet module 242, a whiten module 244, an ECC write module 246,an adaptive write module 248, and a write buffer 250. In someembodiments, the write module 240 may further comprise a compressionmodule, configured to compress data for storage on the solid-statestorage medium 110, one or more encryption modules configured to encryptdata for storage on the solid-state storage medium 110, and so on. Theread module 241 may comprise one or more modules configured to processand/or format data read from the solid-state storage medium 110, whichmay include, but are not limited to: a read buffer 251, an adaptive readmodule 245, an ECC read module 245, a dewhiten module 243, and adepacket module 241.

In some embodiments, the write module 240 comprises a write pipelineconfigured to process data for storage in a plurality of pipeline stagesor modules, as disclosed herein. Similarly, in some embodiments, theread module 241 may comprise a read pipeline configured to process dataread from the solid-state storage array 115 in a plurality of pipelinestages or modules, as disclosed herein.

The packet module 242 may be configured to generate data packetscomprising data to be stored on the solid-state storage medium 110. Thewrite module 240 may be configured to store data in a contextual format,as disclosed above. The contextual format may comprise storing data in apacket format in which a logical interface of the data is associatedwith the data on the solid-state storage medium 110. In someembodiments, the packet format may include a packet header comprisingone or more logical identifiers of the data contained within the packet,or the like. The contextual format may further comprise associating datapackets with sequence information, to define, inter alia, a log-order ofdata packets on the solid-state storage medium 110. The sequenceinformation may comprise sequence numbers, timestamps, or otherindicators that indicate an order of the data packet relative to otherdata packets stored on the solid state storage medium 110. The storagemodule 130 may use the log-based, contextual format of data stored onthe solid-state storage medium 110 to reconstruct portions of thestorage metadata 135, which may include, but is not limited to:reconstructing any-to-any mappings between logical identifiers andphysical storage locations maintained by the logical-to-translationlayer 132, a forward index, a reverse index, and/or the like.

In some embodiments, the packet module 242 may be configured to generatepackets of arbitrary lengths and/or sizes in accordance with the size ofstorage requests received via the request receiver module 231 and/orconfiguration preferences. The packet module 242 may be configured togenerate packets of one or more pre-determined sizes. In one embodiment,in response to a request to write 24 k of data to the solid-statestorage medium 110, the packet module 242 may be configured to generate6 packets, each packet comprising 4 k of the data; in anotherembodiment, the packet module 242 may be configured to generate a singlepacket comprising 24 k of data in response to the request.

FIG. 3 depicts one embodiment of a packet format. A packet 310 maycomprise a packet data segment 312 and a header 314. As disclosed above,the packet data segment 312 may comprise an arbitrary amount of data tobe stored on the solid-state storage medium 110. The header 314 maycomprise contextual metadata pertaining to the packet 310. In someembodiments, the header 314 includes a logical identifier indicator 315,which may indicate one or more logical identifier(s) associated with thedata segment. The header 315 may include other metadata, which mayinclude, but is not limited to: a packet type metadata, a packet sizeand/or length metadata, access control metadata, and so on. The packet310 may be associated with sequence information 318, which may determinea log order of the packet 310 relative to other packets on thesolid-state storage medium 110. As depicted in FIG. 3, the sequenceinformation 318 may be stored separately from the packet 310. In someembodiments, the sequence information 318 may be marked the section ofthe solid-state storage medium 110 comprising the data packet 310 (e.g.,erase block, logical erase block, row, or the like). Alternatively, orin addition, the sequence information 318 may be stored as part of thepacket 310 (e.g., as a field within the header 314 of the packet 310).

The whiten module 244 may be configured to perform one or more whiteningtransformations on the data packets generated by the packet module 242.Data whitening may comprise decorrelating the data, which may providewear-leveling benefits for certain types of solid-state storage medium110. In some embodiments, the whiten module 244 is configured to encryptdata for storage on the solid-state storage medium 110 in one or more ofa media encryption key, a user encryption key, or the like.

The ECC write module 246 may be configured to encode data packetsgenerated by the packet module 242 into respective ECC codewords. Asused herein, an ECC codeword refers data and corresponding errordetection and/or correction information. The ECC write module 246 may beconfigured to implement any suitable ECC algorithm and may be configuredto generate corresponding ECC information (e.g., ECC codewords), whichmay include, but are not limited to: data segments and corresponding ECCsyndromes, ECC symbols, ECC chunks, and/or other structured and/orunstructured ECC information. ECC codewords may comprise any suitableerror-correcting encoding, including, but not limited to: block ECCencoding, convolutional ECC encoding, Low-Density Parity-Check (LDPC)encoding, Gallager encoding, Reed-Solomon encoding, Hamming codes,Multidimensional parity encoding, Hamming codes, cyclic error-correctingcodes, BCH codes, or the like. The ECC read module 245 may be configuredto decode and/or correct ECC codewords generated by the ECC write module246.

The ECC write module 246 may be configured to generate ECC codewords ofa pre-determined size. Accordingly, a single packet may be encoded intoa plurality of different ECC codewords and/or a single ECC codeword maycomprise portions of two or more packets.

In some embodiments, the ECC write module 246 is configured to generateECC codewords, each of which may comprise a data segment of length N anda syndrome of length S. For example, the ECC write module 246 may beconfigured to encode data segments into 240 byte ECC codewords, each ECCcodeword comprising 224 bytes of data and 16 bytes of ECC data. In thisembodiment, the ECC encoding may be capable of correcting more biterrors than the manufacturer of the solid-state storage medium 110requires. In other embodiments, the ECC write module 246 may beconfigured to encode data in a symbolic ECC encoding, such that eachdata segment of length N produces a symbol of length X. The ECC writemodule 246 may encode data according to a selected ECC “strength.” Asused herein, the “strength” of an error-correcting code refers to thenumber of errors that can be detected and/or corrected by use of theerror correcting code. In some embodiments, the strength of the ECCencoding implemented by the ECC write module 246 may be adaptive and/orconfigurable. In some embodiments, the strength of the ECC encoding maybe selected according to the reliability and/or error rate of thesolid-state storage medium 110. As disclosed in further detail herein,the strength of the ECC encoding may be independent of the partitioningof the solid-state storage medium 110, which may allow the storagemodule 130 to select a suitable ECC encoding strength based on theconditions of the solid-state storage medium 110, user requirements, andthe like, as opposed to static and/or pre-determined ECC settingsimposed by the manufacturer of the medium 110.

FIG. 4 depicts one embodiment of data flow 400 between the packet module242 and an ECC write module 246. For clarity, and to avoid obscuring thedetails of the depicted embodiment, other modules of the write module240 are omitted (e.g., whitener module 244). The packet module 242 maybe configured to generate packets 310A-310N in response to one or morerequests to store data on the solid-state storage medium 110. Thepackets 310A-N may comprise respective packet data segments 312A, 312B,and 314N. The packets 310A-N may further comprise contextual metadataembodied in respective headers 314A, 312B, and 314N. The packets 310A-Nmay be processed by, inter alia, the ECC write module 246 to generateECC codewords. In the FIG. 4 embodiment, the ECC codewords comprise ECCcodewords 420A-420X, each of which may comprise a portion of one or moreof the packets 310A-N and a syndrome (not shown). In other embodiments,the ECC codewords may comprise ECC symbols or the like.

As illustrated in FIG. 4, the packets 310A-N may vary in size inaccordance with the size of the respective packet data segments 312A-Nand/or header information 314A-N.

Alternatively, in some embodiments, the packet module 242 may beconfigured to generate packets 310A-N of a fixed, uniform size.

The ECC write module 246 may be configured to generate ECC codewords420A-N having a uniform, fixed size; each ECC codeword 420A-N maycomprise N bytes of packet data and S syndrome bytes, such that each ECCcodeword 420A-N comprises N+S bytes. In some embodiments, each ECCcodeword comprises 240 bytes, and includes 224 bytes of packet data (N)and 16 byes of error correction code (S). The disclosed embodiments arenot limited in this regard, however, and could be adapted to generateECC codewords 420A-N of any suitable size, having any suitable ratiobetween N and S. Moreover, the ECC write module 242 may be furtheradapted to generate ECC symbols, or other ECC codewords, comprising anysuitable ratio between data and ECC information.

As depicted in FIG. 4, the ECC codewords 420A-N may comprise portions ofone or more packets 310A-N; ECC codeword 420D comprises data of packets310A and 310B. The packets 310A-N may be spread between a plurality ofdifferent ECC codewords 420A-N: ECC codewords 420A-D comprise data ofpacket 310A; ECC codewords 420D-H comprise data of packet 310B; and ECCcodewords 420X-420Z comprise data of packet 310N.

Referring back to FIG. 2, the write module 240 may further comprise anadaptive write module 248 configured to buffer data to storage on one ormore of the solid-state storage arrays 115A-N. As disclosed in furtherdetail below, the adaptive write module 248 may be configured to storedata within one or more columns 118 of a solid-state storage array 115.The adaptive write module 248 may be further configured to generateparity data associated corresponding to the layout and/or arrangement ofthe data. As disclosed in further detail below, the parity data may beconfigured to protect data stored within respective rows 117 of thesolid-state storage array 115A-N, and may be generated in accordancewith an adaptive storage layout implemented by the adaptive storagemodule 113.

In some embodiments, the write module 240 further comprises a writebuffer 250 configured to buffer data for storage within respective pagewrite buffers of the solid-state storage medium 110. The write buffer250 may comprise one or more synchronization buffers to synchronize aclock domain of the adaptive storage module 113 with a clock domain ofthe solid-state storage medium 110 (and/or bus 127).

The log storage module 137 may be configured to select storagelocation(s) for data storage and/or may provide addressing and/orcontrol information to the solid-state storage medium 110 via the bus127. Accordingly, the log storage module 137 may provide for storingdata sequentially at an append point within the physical address spaceof the solid-state storage medium 110. The physical address at which aparticular data segment is stored may be independent of the logicalinterface (e.g., logical identifier) of the data segment. Thelogical-to-physical translation layer 132 may be configured to associatethe logical interface of data segments (e.g., logical identifiers of thedata segments) with the physical address(es) of the data segments on thesolid-state storage medium 110. In some embodiments, thelogical-to-physical translation layer 132 may leverage storage metadata135 to perform logical-to-physical translations; the storage metadata135 may include a forward index comprising arbitrary, any-to-anymappings between logical identifiers and physical addresses. The storagemetadata 135 may be maintained in volatile memory, such as the volatilememory 106. In some embodiments, the storage metadata module 134 isconfigured to periodically store portions of the storage metadata 135 ona persistent storage medium, such as the solid-state storage medium 110,persistent storage 105, or the like.

The adaptive storage module 113 may further comprise a read module 241that is configured to read data from the solid-state storage medium 110in response to requests received via the request module 231. The readmodule 241 may be configured to process data read from the solid-statestorage medium 110, and provide the processed data to the storage module130 and/or a storage client 104 (by use of the request module 231). Theread module 241 may comprise one or more modules configured to processand/or format data stored on the solid-state storage medium 110, whichmay include, but are not limited to: read buffer 251, an adaptive readmodule 247, ECC read module 245, a dewhiten module 243, and a depacketmodule 241. In some embodiments, the read module further includes adecompression module, configured to decompress compressed data stored onthe solid-state storage medium 110, one or more decryption modulesconfigured to decrypt encrypted data stored on the solid-state storagemedium 110, and so on. Data processed by the read module 241 may flow tothe storage module 130 and/or storage client 104 via the request module231, and/or other interface or communication channel (e.g., the data mayflow directly to/from a storage client via a DMA or remote DMA module ofthe storage module 130).

Read requests may comprise and/or reference the logical interface of therequested data, such as a logical identifier, a range and/or extent oflogical identifiers, a set of logical identifiers, or the like. Thephysical addresses associated with data of the request may be determinedbased, at least in part, upon the logical-to-physical translation layer132 (and/or the storage metadata 135), metadata pertaining to the layoutof the data on the solid-state storage medium 110, and so on. Data maystream into the read module 241 via a read buffer 251. The read buffer251 may correspond page read buffers to a solid-state storage array115A-N of one of the banks 119A-N. The read buffer 251 may comprise oneor more synchronization buffers configured to synchronize a clock domainof the adaptive storage module 113 with a clock domain of thesolid-state storage medium 110 (and/or bus 127).

The adaptive read module 247 may be configured to reconstruct one ormore data segments from the contents of the read buffer 251.Reconstructing the data segments may comprise recombining and/orreordering contents of the read buffer (e.g., ECC codewords) read fromvarious columns 118 in accordance with a layout of the data on thesolid-state storage arrays 115A-N as indicated by the storage metadata135. In some embodiments, reconstructing the data may comprise strippingdata associated with one or more columns 118 from the read buffer,reordering data of one or more columns 118, and so on.

The read module 241 may comprise an ECC read module 245 configured todetect and/or correct errors in data read from the solid-state storagemedium 110 using, inter alia, the ECC encoding of the data (e.g., asencoded by the ECC write module 246), parity data (e.g., using paritysubstitution), and so on. As disclosed above, the ECC encoding may becapable of detecting and/or correcting a pre-determined number of biterrors, in accordance with the strength of the ECC encoding. The ECCread module 245 may be capable of detecting more bit errors than can becorrected.

The ECC read module 245 may be configured to correct any “correctable”errors using the ECC encoding. In some embodiments, the ECC read module245 may attempt to correct errors that cannot be corrected by use of theECC encoding using other techniques, such as parity substitution, or thelike. Alternatively, or in addition, the ECC read module 245 may attemptto recover data comprising uncorrectable errors from another source. Forexample, in some embodiments, data may be stored in a RAIDconfiguration. In response to detecting an uncorrectable error, the ECCread module 245 may attempt to recover the data from the RAID, or othersource of redundant data (e.g., a mirror, backup copy, or the like).

In some embodiments, the ECC read module 245 may be configured togenerate an interrupt in response to reading data comprisinguncorrectable errors. The interrupt may comprise a message indicatingthat the requested data is in error, and may indicate that the ECC readmodule 245 cannot correct the error using the ECC encoding. The messagemay comprise the data that includes the error (e.g., the “corrupteddata”).

The interrupt may be caught by the storage module 130 or other process.In some embodiments, the interrupt is received by the datareconstruction module 170, which, in response, may be configured toreconstruct the data using parity substitution, or other reconstructiontechnique, as disclosed herein. Parity substitution may compriseiteratively replacing portions of the corrupted data with a “paritymask” (e.g., all ones) until a parity calculation associated with thedata is satisfied. The masked data may comprise the uncorrectableerrors, and may be reconstructed using other portions of the data inconjunction with the parity data. Parity substitution may furthercomprise reading one or more ECC codewords from the solid-state storagearray 115A-N (in accordance with an adaptive data structure layout onthe array 115), correcting errors within the ECC codewords (e.g.,decoding the ECC codewords), and reconstructing the data by use of thecorrected ECC codewords and/or parity data. In some embodiments, thecorrupted data may be reconstructed without first decoding and/orcorrecting errors within the ECC codewords.

Alternatively, data reconstruction module 170 may be configured toreplace the corrupted data with another copy of the data, such as abackup or mirror copy, and then may use the replacement data of therequested data packet or return it to the read module 241. In anotherembodiment, the storage module 130 stores data in a RAID configuration,from which the corrupted data may be recovered, as described above.

As depicted in FIG. 2, the solid-state storage medium 110 may bearranged into a plurality of independent banks 119A-N. Each bank maycomprise a plurality of solid-state storage elements arranged intorespective solid-state storage arrays 115A-N, as disclosed above. Thebanks 119A-N may be configured to operate independently; the adaptivestorage module 113 may configure a first bank 119A to perform a firststorage operation while a second bank 119B is configured to perform adifferent storage operation. The adaptive storage module 113 may furthercomprise a bank controller 252 configured to selectively route dataand/or commands between the adaptive storage module 113 and the banks119A-N. In some embodiments, adaptive storage module 113 may beconfigured to read data from a bank 119A while filling the write buffer250 for storage on another bank 119B and/or may interleave one or morestorage operations between one or more banks 119A-N. Further embodimentsof multi-bank storage operations and data pipelines are disclosed inU.S. Patent Application Publication No. 2008/0229079 (U.S. patentapplication Ser. No. 11/952,095), entitled, “Apparatus, System, andMethod for Managing Commands of Solid-State Storage Using BankInterleave,” filed Dec. 6, 2007 for David Flynn et al., which is herebyincorporated by reference in its entirety.

As disclosed above, the groomer module 138 may be configured to reclaimstorage resources of the solid-state storage medium 110. The groomermodule 138 may operate as an autonomous, background process, which maybe suspended and/or deferred while other storage operations are inprocess. The log storage module 137 and groomer module 138 may managestorage operations so that data is systematically spread throughout aphysical address space of the solid-state storage medium 110, which mayimprove performance, data reliability, and avoid overuse and underuse ofany particular storage locations, thereby lengthening the useful life ofthe solid-state storage medium 110 (e.g., wear-leveling, etc.).Accordingly, in some embodiments, the storage module 130 treats thephysical address space of the solid-state storage medium 110 as a cycle.Data is incrementally appended to the solid-state storage medium 110from an initial append point, which may correspond to a particularphysical address within one or more of the banks 119A-N (e.g., physicaladdress 0 of bank 119A). Upon reaching the end of the physical addressspace (e.g., physical address N of bank 119N), the append point revertsto the initial position (or next available storage location).

Operations to overwrite and/or modify data stored on the solid-statestorage medium 110 may be performed “out-of-place.” The obsolete versionof the data may remain on the storage medium 110 while the updatedversion of the data may be appended at the append point. Similarly, anoperation to delete, erase, or TRIM data from the solid-state storagemedium 110 may comprise indicating that the data is invalid (e.g., doesnot need to be retained on the solid-state storage medium 110). Markingdata as invalid may comprise modifying a mapping between the logicalidentifier of the data and the physical address of the invalid data,marking the physical address as invalid in a reverse index, or the like.

The groomer module 138 may be configured to select selections of thesolid-state storage medium 110 for recovery. As used herein, a “section”of the solid-state storage medium 110 may include, but is not limitedto: an erase block, a logical erase block, a die, a plane, one or morepages, a portion of a solid-state storage element 116A-Y, a portion of arow 117 of a solid-state storage array 115, or the like. A section maybe selected for grooming in response to various criteria, which mayinclude, but are not limited to: age criteria (e.g., data refresh),error metrics, reliability metrics, wear metrics, resource availabilitycriteria, an invalid data threshold, or the like. A grooming or storagerecovery operation may comprise relocating valid data on the section (ifany). The operation may further comprise preparing the section forreuse, which may comprise erasing the section, marking the section witha sequence indicator, such as the sequence indicator 318, and/or placingthe section in a queue of storage sections that are available to storedata. The groomer module 138 may be configured to schedule groomingoperations with other storage operations and/or requests. In someembodiments, The adaptive storage module 113 may comprise a groomerbypass (not shown) configured to relocate data from a storage section bytransferring data read from the section from the read module 241directly into the write module 240 without being routed out of theadaptive storage module 113.

The adaptive write module 248 may be further configured to manageout-of-service conditions on the solid-state storage medium 110. As usedherein, a section of the solid-state storage medium 110 that is“out-of-service” (OOS) refers to a section that is not currently beingused to store valid data. The storage module 130 may be configured tomonitor storage operations performed on the solid-state storage medium110 and/or actively scan the solid-state storage medium 110 to identifysections that should be taken out of service. The storage metadata 135may comprise OOS metadata that identifies OOS sections of thesolid-state storage medium 110. The adaptive write module 248 may beconfigured to avoid OOS section by, inter alia, stream padding (and/ornonce) data to the write buffer such that padding data will map to theidentified OOS sections. In some embodiments, the adaptive storagemodule 113 may be configured to manage OOS conditions by replacing OOSsections of the solid-state storage medium 110 with replacementsections. Alternatively, or in addition, a hybrid OOS approach may beemployed. The padding approach to managing OOS conditions may be used inportions of the solid-state storage medium 110 comprising a relativelysmall number of OOS storage divisions; as the number of OOS sectionsincreases, the solid-state adaptive storage module 113 may replace oneor more of the OOS sections with replacements. Further embodiments ofapparatus, systems, and methods for detecting and/or correcting dataerrors, and managing OOS conditions, are disclosed in U.S. PatentApplication Publication No. 2009/0287956 (U.S. application Ser. No.12/467,914), entitled, “Apparatus, System, and Method for Detecting andReplacing a Failed Data Storage,” filed May 18, 2009, and U.S. PatentApplication Publication No. 2013/0019072 (U.S. application Ser. No.13/354,215), entitled, “Apparatus, System, and Method for ManagingOut-of-Service Conditions,” filed Jan. 19, 2012 for John Strasser et al,each of which is hereby incorporated by reference in its entirety.

As disclosed above, the solid-state storage medium 110 may comprise oneor more solid-state storage arrays 115A-N. A solid-state storage array115A-N may comprise a plurality of independent columns 118 (respectivesolid-state storage elements 116A-Y), which may be coupled to theadaptive storage module 113 in parallel via the bus 127. Accordingly,storage operations performed on an array 115A-N may be performed on eachof the solid-state storage elements 116A-Y comprising the array 115A-N.Performing a storage operation on an array 115A-N may compriseperforming the storage operation on each of the plurality of solid-statestorage elements 116 comprising the array 115A-N: a read operation maycomprise reading a physical storage unit (e.g., page) from a pluralityof solid-state storage elements 116A-Y; a program operation compriseprogramming a physical storage unit (e.g., page) on a plurality ofsolid-state storage elements 116A-Y; an erase operation may compriseerasing a section (e.g., erase block) on a plurality of solid-statestorage elements 116A-Y; and so on. Accordingly, a program operation maycomprise the write module 240 streaming data to program buffers of aplurality of solid-state storage elements 116A-Y (via the write buffer250 and bus 127) and, when the respective program buffers aresufficiently full, issuing a program command to the solid-state storageelements 116A-Y. The program command may cause one or more storage unitson each of the storage elements 116A-Y to be programmed in parallel.

FIG. 5A depicts one embodiment 500 of a solid-state storage array 115.As disclosed above, the solid-state storage array 115 may comprise aplurality of independent columns 118, each of which may correspond to arespective solid-state storage element 116A-Y. The embodiment for asolid-state storage array 115 depicted in FIG. 5 comprises twenty fivecolumns 118 (e.g., solid-state storage element 0 116A throughsolid-state storage element 24 116Y). The solid-state storage elements116A-Y comprising the array may be communicatively coupled to theadaptive storage module 113 in parallel by the bus 127. The bus 127 maybe capable of communicating data, address, and/or control information toeach of the solid-state storage elements 116A-Y. The parallel connectionmay allow the adaptive storage module 113 to manage the solid-statestorage elements 116A-Y as a single, logical storage element (array115), as described above.

The solid-state storage elements 116A-Y may be partitioned intosections, such as physical storage divisions 530 or physical eraseblocks. Each erase block may comprise a plurality of physical storageunits 532, such as pages. The physical storage units 532 within aphysical storage division 530 may be erased as a group. Although FIG. 5Adepicts a particular partitioning scheme, the disclosed embodiments arenot limited in this regard, and could be adapted to use solid-statestorage elements 116A-Y partitioned in any suitable manner.

As depicted in FIG. 5A, the columns 118 of the array 115 may correspondto respective solid-state storage elements 116A-Y. Accordingly, thearray 115 of FIG. 5A comprises twenty five columns 118. Rows of thearray 117 may correspond to physical storage units 532 and/or 530 of aplurality of the columns 118.

FIG. 5B is a block diagram 501 of another embodiment of a solid-statestorage array 115. As disclosed above, the solid-state storage array 115may comprise a plurality of rows 117, which may correspond to storageunits on a plurality of different columns 118 within the array 115. Therows 117 of the solid-state storage array 115 may include logicalstorage divisions 540, which may comprise physical storage divisions ona plurality of the solid-state storage elements 116A-Y. In someembodiments, a logical storage division 540 may comprise a logical eraseblock, comprising physical erase blocks on each of the solid-statestorage elements 116A-Y in the array 115. A logical page 542 maycomprise physical storage units (e.g., pages) on a plurality of thesolid-state storage elements 116A-Y.

Storage operations performed on the solid-state storage array 515 mayoperate on multiple solid-state storage elements 516: an operation toprogram data to a logical storage unit 542 may comprise programming datato each of twenty-five (25) physical storage units (e.g., one storageunit per non-volatile storage element 116A-Y); an operation to read datafrom a logical storage unit 542 may comprise reading data fromtwenty-five (25) physical storage units (e.g., pages); an operation toerase a logical storage division 540 may comprise erasing twenty-fivephysical storage divisions (e.g., erase blocks); and so on. Since thecolumns 118 are independent, storage operations may be performed acrossdifferent sets and/or portions of the array 115. For example, a readoperation on the array 115 may comprise reading data from physicalstorage unit 532 at a first physical address of solid-state storageelement 116A and reading data from a physical storage unit 532 at adifferent physical address of one or more other solid-state storageelements 116B-N.

Arranging non-volatile storage elements 116A-Y into a solid-statestorage array 115 may be used to address certain properties of thesolid-state storage medium 110. Some embodiments may comprise asymmetricsolid-state storage medium 110; it may take longer to program data ontothe solid-state storage elements 116A-Y than it takes to read datatherefrom (e.g., ten times as long). Moreover, in some cases, data mayonly be programmed to physical storage divisions 530 that have firstbeen initialized (e.g., erased). Initialization operations may takelonger than a program operations (e.g., ten times as long as a program,and by extension one hundred times as long as a read operation).Managing groups of solid-state storage elements 116A-Y in an array 115(and/or interleaved banks 119A-N as disclosed herein), may allow thestorage module 130 to address the asymmetric properties of thesolid-state storage medium 110. In some embodiments, the asymmetry inread, program, and/or erase operations is addressed by performing theseoperations on multiple solid-state storage elements 116A-Y in parallel.In the embodiment depicted in FIG. 5B, programming asymmetry may beaddressed by programming twenty-five (25) storage units in a logicalstorage unit 542 in parallel. Initialization operations may also beperformed in parallel. Physical storage divisions 530 on each of thesolid-state storage elements 116A-Y may be initialized as a group (e.g.,as logical storage divisions 542), which may comprise erasingtwenty-five (25) physical erase blocks in parallel.

In some embodiments, portions of the solid-state storage array 115 maybe configured to store data and other portions of the array 115 may beconfigured to store error detection and/or recovery information. Columns118 used for data storage may be referred to as “data columns” and/or“data solid-state storage elements.” Columns used to store data errordetection and/or recovery information may be referred to as a “paritycolumn” and/or “recovery column.” The array 515 may be configured in anoperational mode in which one of the solid-state storage elements 116Yis used to store parity data, whereas other solid-state storage elements116A-X are used to store data. Accordingly, the array 115 may comprisedata solid-state storage elements 116A-X and a recovery solid-statestorage element 116Y. In this operational mode, the effective storagecapacity of the rows (e.g., logical pages 542) may be reduced by onephysical storage unit (e.g., reduced from 25 physical pages to 24physical pages). As used herein, the “effective storage capacity” of astorage unit refers to the number of storage units or divisions that areavailable to store data and/or the total amount of data that can bestored on a logical storage unit. The operational mode described abovemay be referred to as a “24+1” configuration, denoting that twenty-four(24) physical storage units 532 are available to store data, and one (1)of the physical storage units 532 is used for parity. The disclosedembodiments are not limited to any particular operational mode and/orconfiguration, and could be adapted to use any number of the solid-statestorage elements 116A-Y to store error detection and/or recovery data.

As disclosed above, the adaptive storage module 113 may be configured tointerleave storage operations between a plurality of solid-state storagearrays 115A-N of independent banks 119A-N, which may further ameliorateasymmetry between erase, program, and read operations on the solid-statestorage medium 110. FIG. 5C depicts one embodiment of a adaptive storagemodule 113 configured to manage logical erase blocks 540 that spanmultiple arrays 115A-N of multiple banks 119A-N. Each bank 119A-N maycomprise one or more solid-state storage arrays 115A-N, which, asdisclosed herein, may comprise a plurality of solid-state storageelements 116A-Y coupled in parallel by a respective bus 127A-N. Theadaptive storage module 113 may be configured to perform storageoperations on the storage elements 116A-Y of the arrays 119A-N inparallel and/or in response to a single command and/or signal.

Some operations performed by the adaptive storage module 113 may crossbank boundaries. The adaptive storage module 113 may be configured tomanage groups of logical erase blocks 540 that include erase blocks ofmultiple arrays 115A-N within different respective banks 119A-N. Eachgroup of logical erase blocks 540 may comprise erase blocks 531A-N oneach of the arrays 115A-N. The erase blocks 531A-N comprising thelogical erase block group 540 may be erased together (e.g., in responseto a single erase command and/or signal or in response to a plurality ofseparate erase commands and/or signals). Performing erase operations onlogical erase block groups 540 comprising large numbers of erase blocks531A-N within multiple arrays 115A-N may further mask the asymmetricproperties of the solid-state storage medium 110, as disclosed above.

The adaptive storage module 113 may be configured to perform somestorage operations within boundaries of the arrays 115A-N and/or banks119A-N. In some embodiments, the read, write, and/or program operationsmay be performed within rows 117 of the solid-state storage arrays115A-N (e.g., on logical pages 542A-N within arrays 115A-N of respectivebanks 119A-N). As depicted in FIG. 5C, the logical pages 542A-N of thearrays 115A-N may not extend beyond single arrays 115A-N and/or banks119A-N. The log storage module 137 and/or bank interleave module 252 maybe configured to append data to the solid-state storage medium 110 byinterleaving and/or scheduling storage operations sequentially betweenthe arrays 15A-N of the banks 119A-N.

FIG. 5D depicts one embodiment of storage operations that areinterleaved between a solid-state storage arrays 115A-N of respectivebanks 119A-N. In the FIG. 5D embodiment, the bank interleave module 252is configured to interleave programming operations between logical pages542A-N (rows 117) of the arrays 115A-N within the banks 119A-N. Asdisclosed above, the write module 240 may comprise a write buffer 250,which may have sufficient capacity to fill write buffers one or morelogical pages 542A-N of an array 115A-N. In response to filling thewrite buffer 250 (e.g., buffering data sufficient to fill a portion of alogical page 542A-N), the adaptive storage module 113 may be configuredto stream the contents of the write buffer 250 to program buffers of thesolid-state storage elements 116A-Y comprising one of the banks 119A-N.The solid-state adaptive storage module 113 may then issue a programcommand and/or signal to the solid-state storage array 115A-N to storethe contents of the program buffers to a specified logical page 542A-N.The log storage module 137 and/or bank interleave module 252 may beconfigured to provide control and addressing information to thesolid-state storage elements 116A-Y of the array 115A-N using a bus127A-N, as disclosed above.

The bank interleave module 252 may be configured to append data to thesolid-state storage medium 110 by programming data to the arrays 115A-Nin accordance with a sequential interleave pattern. The sequentialinterleave pattern may comprise programming data to a first logical page(LP_0) of array 115A within bank 119A, followed by the first logicalpage (LP_0) of array 115B within the next bank 119B, and so on, untildata is programmed to the first logical page LP_0 of each array 115A-Nwithin each of the banks 119A-N. As depicted in FIG. 5D, data may beprogrammed to the first logical page LP_0 of array 115A in bank 119A ina program operation 243A. The bank interleave module 252 may then streamdata to the first logical page (LP_0) of the array 115B in the next bank119B. The data may then be programmed to LP_0 of array 115B bank 119B ina program operation 243B. The program operation 243B may be performedconcurrently with the program operation 243A on array 115A of bank 19A;the adaptive storage module 113 may stream data to array 115B and/orissue a command and/or signal for the program operation 243B, while theprogram operation 243A is being performed on the array 115A. Data may bestreamed to and/or programmed on the first logical page (LP_0) of thearrays 115C-N of the other banks 119C-119N following the same sequentialinterleave pattern (e.g., after data is streamed and/or programmed toLP_0 of array 115A of bank 119B, data is streamed and/or programmed toLP_0 of array 115C of bank 119C in program operation 243C, and so on).Following the programming operation 243N on LP_0 of array 115N withinthe last bank 119N, the bank interleave controller 252 may be configuredto begin streaming and/or programming data to the next logical page(LP_1) of array 115A within the first bank 119A, and the interleavepattern may continue accordingly (e.g., program LP_1 of array 115B bank119B, followed by LP_1 of array 115C bank 119C through LP_1 of array115N bank 119N, followed by LP_2 of array 115A bank 119A, and so on).

Sequentially interleaving programming operations as disclosed herein mayincrease the time between concurrent programming operations on the samearray 115A-N and/or bank 119A-N, which may reduce the likelihood thatthe adaptive storage module 113 will have to stall storage operationswhile waiting for a programming operation to complete. As disclosedabove, programming operations may take significantly longer than otheroperations, such as read and/or data streaming operations (e.g.,operations to stream the contents of the write buffer 250 to an array115A-N via the bus 127A-N). The interleave pattern of FIG. 5D may beconfigured to avoid consecutive program operations on the same array115A-N and/or bank 119A-N; programming operations on a particular array115A-N may be separated by N−1 programming operations on other banks(e.g., programming operations on array 115A are separated by programmingoperations on arrays 115A-N). As such, programming operations on array119A are likely to be complete before another programming operationneeds to be performed on the array 119A.

As depicted in FIG. 5D, the interleave pattern for programmingoperations may comprise programming data sequentially across rows 117(e.g., logical pages 542A-N) of a plurality of arrays 115A-N. Asdepicted in FIG. 5E, the interleave pattern may result in interleavingprogramming operations between arrays 115A-N of banks 119A-N, such thatthe erase blocks of each array 115A-N (erase block groups EBG_0-N) arefilled at the same rate. The sequential interleave pattern programs datato the logical pages of the first erase block group (EBG_0) in eacharray 115A-N before programming data to logical pages LP_0 through LP_Nof the next erase block group (EBG_1), and so on (e.g., wherein eacherase block comprises 0-N pages). The interleave pattern continues untilthe last erase block group EBG_N is filled, at which point theinterleave pattern continues back at the first erase block group EBG_0.

The erase block groups of the arrays 115A-N may, therefore, be managedas logical erase blocks 540A-N that span the arrays 115A-N. Referring toFIG. 5C, a logical erase block group 540 may comprise erase blocks531A-N on each of the arrays 115A-N within the banks 119A-N. Asdisclosed above, managing groups of erase blocks (e.g., logical eraseblock group 540) may comprise erasing each of the erase blocks 531A-Nincluded in the group 540. In the FIG. 5E embodiment, erasing thelogical erase block group 540A may comprise erasing EBG_0 of arrays115A-N in banks 119A-N, erasing a logical erase block group 540B maycomprise erasing EBG_1 of arrays 115A-N in banks 517A-N, erasing logicalerase block group 540C may comprise erasing EBG_2 of arrays 115A-N inbanks 517A-N, and erasing logical erase block group 540N may compriseerasing EBG_N of arrays 115A-N in banks 517A-N. Other operations, suchas grooming, recovery, and the like may be performed at the granularityof the logical erase block groups 540A-N; recovering the logical eraseblock group 540A may comprise relocating valid data (if any) stored onEBG_0 on arrays 115A-N in banks 517A-N, erasing the erase blocks of eachEBG_0 in arrays A-N, and so on. Accordingly, in embodiments comprisingfour banks 119A-N, each bank 119A-N comprising a respective solid-statestorage array 115A-N comprising twenty five storage elements 116A-Y,erasing, grooming, and/or recovering a logical erase block group 540comprises erasing, grooming, and/or recovering one hundred physicalerase blocks 530. Although particular multi-bank embodiments aredescribed herein, the disclosure is not limited in this regard and couldbe configured using any multi-bank architecture comprising any number ofbanks 119A-N of arrays 115A-N comprising any number of solid-statestorage elements 116A-Y.

Referring back to FIG. 1, the storage module 130 may be configured tostore data segments in one or more different arrangements and/or layoutswithin a solid-state storage array 115. In some embodiments, data may bestored “horizontally” within rows 117 of the array 115 (e.g.,horizontally within logical storage units 542 of the array 115).Accordingly, a datastructure, such as an ECC codeword or packet, may bespread across a plurality of the storage elements 116A-Y comprising thearray 115. In some embodiments, data may be stored horizontally withinone or more “channels” within the array 115. As used herein, a channelrefers to a subset of one or more independent columns 118 of the array115. Data may be arranged horizontally within the channels. An array 115comprising N columns 118 used for storing data may be divided into aconfigurable number of independent channels X, each comprising Y columns118 of the array 115. In the FIG. 1 embodiment having a “24+1”configuration that comprises twenty four columns 118 for storing data,the channel configurations may include, but are not limited to: 24channels each comprising a single column 118; twelve channels eachcomprising two solid-state storage elements; eight channels eachcomprising three solid-state storage elements; six channels eachcomprising 6 columns 118; and so on. In some embodiments, the array 115may be divided into heterogeneous channels, such as a first channelcomprising twelve columns 118 and six other channels each comprising twocolumns 118.

FIG. 6A is a block diagram of one embodiment of a system 600 foradaptive data storage. The system 600 may comprise a solid-state storagearray 115 comprising twenty five solid-state storage elements 116A-Yoperating in a “24+1” configuration, in which twenty four of thesolid-state storage elements 116A-X are used to store data, and onestorage element (116Y) is used to store parity data.

The write module 240 may comprise a packet module 242 configured togenerate data packets comprising data for storage on the array 115, asdisclosed above. In the FIG. 6A embodiment, the packet module 242 isconfigured to format data into a packet format 610, comprising a packetdata segment 612 and metadata 614 (e.g., header). The header 614 maycomprise a logical identifier associated with the packet data segment612, a sequence number, or the like, as disclosed above. In the FIG. 6Aembodiment, the packet module 242 is configured to generate packets 610of a fixed size (520 byte packet data segment 612 and 8 bytes ofmetadata 614).

The ECC write module 246 is configured to generate ECC datastructures(ECC codewords 620) comprising portions of one or more packets 610 asdisclosed above. The ECC codewords 620 may be of a fixed size. In theFIG. 6A example, each ECC codeword 620 comprises 224 bytes of packetdata and a 16 byte error-correcting code or syndrome. Althoughparticular sizes and/or configurations of packets 610 and ECC codewordsare disclosed herein, the disclosure is not limited in this regard andcould be adapted to use any size packets 610 and/or ECC codewords 620.Moreover, in some embodiments, the size of the datastructures (e.g.,packets 610 and/or ECC codewords 620) may vary. For example, the sizeand/or contents of the packets 610 and/or ECC codewords 620 may beadapted according to out-of-service conditions, as disclosed above.

Data of the packet 610A may be included in a plurality of ECC codewords620 (e.g., ECC codewords 621, 622, and 623). The ECC codeword 621 maycomprise 224 bytes of the packet 610A, the ECC codeword 622 may compriseanother 224 bytes of the packet 610A, and the ECC codeword 623 maycomprise the remaining 72 bytes of the packet 610A and 152 bytes of thenext packet 610B.

The adaptive write module 248 may be configured to layout datahorizontally within rows of the array 115. The adaptive write module 248may be configured to buffer and/or arrange data segments (e.g., the ECCcodewords 621, 622, and 623) into 24 byte segments. The adaptive writemodule 248 may be capable of buffering one or more ECC codewords 620.For example, the write buffer 320 may comprise ten, 24 byte rows, whichis sufficient to buffer a full 240 byte ECC codeword 620.

The adaptive write module 248 may be further configured to stream 24byte segments to a parity module 637, which may be configured togenerate a parity byte for each 24 byte segment. The adaptive writemodule 248 streams the resulting 25 bytes to the array 115 via the bankcontroller 252 and bus 127 (and/or write buffer 250, as disclosedabove). The adaptive storage module 113 may be configured to stream datafrom the adaptive write module 248 to program buffers of the solid-statestorage array 115 (e.g., stream to a program buffer of one of thesolid-state storage elements 116A-Y). Accordingly, each cycle of bus 127may comprise transferring a byte to the program buffer of a respectivecolumn 118; solid-state storage elements 116A-X receive data bytes andsolid-state storage element 116Y receives the parity byte generated bythe parity module 637. Data of the ECC codewords 620 may be byte-wiseinterleaved between the solid-state storage elements 116A-X; eachsolid-state storage element 116A-X receives 10 bytes of each 240 byteECC codeword 620. Accordingly, the adaptive write module 248 may beconfigured to stream “data rows” 667 to the solid-state storage array115. As used herein, a data row 667 refers to a data set comprising datafor each of a plurality of columns 118 within the array 115. The datarow 667 may comprise a byte of data for each column 0-23. The data row667 may further comprise a parity byte corresponding to the data bytes(e.g., a parity byte corresponding to the data bytes for columns 0-23).The data row 667 may be streamed to respective program buffers of thesolid-state storage elements 116A-Y on the bus 127. In the horizontaldata configuration of FIG. 6A, streaming a 240 byte ECC codeword 620 tothe array 115 may comprise streaming ten separate data rows 667 to thearray 115, each data row comprising 24 data bytes (one for each datasolid-state storage element 116A-X) and a corresponding parity byte.

The storage location or offset 636 of the packet 610A within the logicalpage 650A may be determined based upon the horizontal layout of the data610A of the packet. The offset 636 may identify the location of the ECCcodewords 621, 622, and/or 623 comprising the packet 610A (and/or mayidentify the location of the last ECC codeword 623 comprising data ofthe packet 610A). Accordingly, in some embodiments, the offset may berelative to one or more datastructures on the logical storage element515 (e.g., a packet offset and/or ECC codeword offset). Another offset638 may identify the location of the last ECC codeword of a next packet620 (e.g., packet 610B), and so on.

As depicted in FIG. 6A, each of the ECC codewords 621, 622, and 623 arehorizontally spread across the storage elements 116A-Y comprising thelogical page 650A (e.g., 10 bytes of the ECC codewords 621, 622, and 623are stored on each solid-state storage element 116A-X). Accessing thepacket 610A may, therefore, comprise accessing each of the ECC codewords621, 622, and 623 (and each of the storage elements 116A-X).

FIG. 6B depicts one embodiment of horizontal, adaptive data storage 601.The FIG. 6B embodiment depicts a horizontal layout 601 of the ECCcodeword 621 on the array 115 of FIG. 6A. Data Do denotes a first byteof the ECC codeword 621, and data D₂₃₉ denotes the last byte (byte 240)of the ECC codeword 621. As illustrated in FIG. 6B, each column 118 ofthe solid-state storage array 115 comprises ten (10) bytes of the ECCcodeword 621, and the data of the ECC codeword 621 is horizontallyspread across a row 117 of the array 115 (e.g., horizontally spreadacross solid-state storage elements 116A-X of the array 115). FIG. 6Balso depicts a data row 667 as streamed to (and stored on) thesolid-state storage array 115. As illustrated in FIG. 6B, the data row667 comprises a bytes 0 through 23 of the ECC codeword D, each stored ona respective one of the columns 118. The data row 667 further comprisesa parity byte 668 corresponding to the contents of the data row 667(bytes D₀ through D₂₃).

Since the data is spread across the columns 0-23 (solid-state storageelements 116A-X), reading data of the ECC codeword 621 may requireaccessing a plurality of columns 118. Moreover, the smallest read unitmay be an ECC codeword 620 (and/or packet 610). Reading a packet 310stored horizontally on the solid-state storage array 115 may, therefore,incur significant overhead. Referring back to FIG. 6A, reading thepacket 610A may require transferring data of the logical page 650A intorespective read buffers of the storage elements 116A-X (e.g., storageelements 0 through 23). Transferring the contents of a page into theread buffer may incur a latency of Tr (read latency). As used herein,read time or read latency Tr refers to the time needed to transfer thecontents of a physical storage unit (e.g., physical page) into a readbuffer of a solid-state storage element 116A-Y. In the FIG. 6Aembodiment, the read time Tr may, therefore, refer to the time requiredto transfer a physical page of each of the solid-state storage elements116A-X into a respective read buffer. Accordingly, the read time Tr of alogical storage unit 650 may correspond to the “slowest” read time ofthe constituent storage elements 116A-X.

In the FIG. 6A embodiment, each ECC codeword comprises 240 bytes, andeach packet comprises 520 bytes. The size of a logical page, however,may be much larger. For example, each page may comprise 2 kbytes (ormore), and as such, a logical page may comprise forty-eight (48) Kbytes.Accordingly, reading a packet may require transferring 48 kbytes of datato access 520 bytes (or less) of data.

Upon transferring the data into the respective read buffers, data may bestreamed into the read module 241 by way of the 24 byte storage bus 127(and bank controller 252). The stream time (Ts) may refer to the timerequired to stream the ECC codeword 620 (or packet 610) into thepipeline 241. In the horizontal layout of FIG. 6A, the stream time Tsmay be ten (10) cycles of the bus 127 because, as disclosed above, eachcolumn 118 comprises ten (10) bytes of the ECC codeword 620. Therefore,although the horizontal arrangement incurs a high retrieval overhead,the stream overhead is relatively low (only ten (10) clock cycles).

Given the data arrangement within the solid-state storage array 115, andthe latencies disclosed herein, an input/output operations per second(TOPS) metric may be quantified. The TOPS to read an ECC codeword 620may be expressed as:

$\begin{matrix}{{IOPS}_{r} = \frac{C}{\left( {{Tr} + {Ts}} \right)}} & {{Eq}.\mspace{14mu} 1}\end{matrix}$

In Equation 1, Tr is the read time of the solid-state storage elements116A-Y, Ts is the stream time (e.g., the clock speed times the number ofcycles required), and C is the number of independent columns used 118 tostore the data. Equation 1 may be scaled by the number of independentbanks 119A-N available to the adaptive storage module 113. In theHorizontal data structure layout of FIGS. 6A and 6B, Equation 1 may beexpressed as:

$\begin{matrix}{{IOPS}_{r} = \frac{24}{\left( {{Tr} + {10*{Sc}}} \right)}} & {{Eq}.\mspace{14mu} 2}\end{matrix}$

In Equation 2, the number of columns is twenty-four (24), and Sc is thecycle time of the bus 127. The cycle time is scaled by ten (10) since,as disclosed above, a horizontal 240 byte ECC codeword 620 may bestreamed in ten (10) cycles of the bus 127.

The storage module may be configured to store data in differentconfigurations, layouts, and/or arrangements on the solid-state storagemedium 110. As disclosed above, in some embodiments, the adaptive writemodule 248 is configured to arrange data within respective independentcolumns, each comprising a subset of the columns 118 of the solid-statestorage array 115 (e.g., subsets of the solid-state storage elements116A-Y). Alternatively, or in addition, the adaptive write module 248may be configured to store data vertically within respective “verticalstripes.” The vertical stripes may have a configurable depth, which maya factor of the page size of the solid-state storage elements 116A-Ycomprising the array 115.

FIG. 6C depicts another embodiment of a system 602 for adaptive datalayout. In the FIG. 6C embodiment, the adaptive write module 248 may beconfigured to store data in a vertical layout within the array 115. Theadaptive write module 248 may be configured to buffer ECC codewords 620for storage on respective columns 118 of the solid-state storage array115 (including the ECC codewords 621, 622, and 623 disclosed herein).The ECC codewords 610 may be streamed to respective columns 118 of thearray through a write buffer 250 (not shown). Accordingly, each cycle ofthe bus 127 may comprise streaming a byte of a different respective ECCcodeword 610 to each of the columns 116A-X. The adaptive write module248 may be further configured to generate parity data 637 correspondingto the different ECC codewords 610 for storage on a parity column (e.g.,solid-state storage element 116Y). Accordingly, each stream cycle maycomprise streaming a byte of a respective ECC codeword 610 to arespective column 118 along with a corresponding parity byte to a paritycolumn 118.

As depicted in FIG. 6C, the adaptive write module 248 may be configuredto buffer and rotate ECC codewords for vertical storage withinrespective columns 118 of the array 115: the ECC codeword 621 may streamto (and be stored vertically on) column 0 (solid-state storage element116A), the ECC codeword 622 may be stored vertically on column 1(solid-state storage element 116B), the ECC codeword 623 may be storedvertically on column 2 (solid-state storage element 116C), and so on(the ECC codeword 629 may be stored vertically in the column 23,solid-state storage element 116X). Column 24 (solid-state storageelement 116Y) may be configured to store parity data corresponding tothe ECC codewords, as disclosed above. Alternatively, the parity column24 may be used to store additional ECC codeword data.

In some embodiments, the adaptive storage module 113 may comprise aplurality of packet modules 242 and/or ECC write modules 246 (e.g.,multiple, independent write modules 240) configured to operate inparallel. Data of the parallel write modules 240 may flow into theadaptive write module 248 in a checkerboard pattern such that the datais arranged in the vertical format disclosed herein.

The vertical arrangement of FIG. 6C may store data of each ECC codeword620 within a respective column 118 of the array 115. Accordingly, eachdata row 667 streamed to the array 115 may comprise a byte correspondingto a respective ECC codeword 620. The data row 667 may further comprisea corresponding parity byte; the data rows 667 may be configured tostream data of respective ECC codewords 660 to program buffers ofrespective data columns (e.g., solid-state storage elements 116A-Y), anda corresponding parity byte to a parity column (e.g., column 116Y).Accordingly, the data rows 667 may be stored with byte-wise parityinformation, each byte of a row 667, and stored within the solid-statestorage elements 116A-X, may be reconstructed by use of the other bytesin the row 667 (and stored in other solid-state storage elements 116A-X)and the corresponding parity byte.

FIG. 6D depicts one embodiment of vertical, adaptive data storage 603.The FIG. 6D embodiment illustrates a vertical storage configurationwithin the solid-state storage array 115. As illustrated in FIG. 6D,data D₀ through D₂₃₉ of the ECC codeword 621 is stored vertically incolumn 0, Data O₀ through O₂₃₉ of ECC codeword 622 is stored verticallyin column 1, Data Q₀ through Q₂₃₉ of ECC codeword 623 is storedvertically in column 2, and data Z₀ through Z₂₃₉ of ECC codeword 629 isstored vertically in column 23. The vertical storage configuration ofother data of other ECC codewords 620 (R-Y) is also depicted.

FIG. 6D also depicts one embodiment of a data row 667 as streamed to,and stored on, the solid-state storage array 115. As illustrated in FIG.6D, the data row 667 comprises a byte of each of a plurality of ECCcodewords 620 (ECC codewords D, O, R, S, T, U . . . V, W, X, Y, and Z),each of which is streamed to, and stored within, a respective column 118(respective solid-state storage element 116A-X). The data row 667further comprises a parity byte 668 corresponding to the data within thedata row 667. Accordingly, the parity byte 668 corresponds to byte 0 ofECC codewords D, O, R, S, T, U . . . V, W, X, Y, and Z.

The vertical configuration of FIGS. 6C and 6D may result in a differentTOPS metric. The vertical arrangement of the ECC codewords 620 mayreduce overhead due to read time Tr, but may increase the streamoverhead Ts. As data is streamed from a logical storage element 116A-Y,each byte on the bus 127 may correspond to a different, respective datasegment (e.g., different ECC codeword 620). As such, twenty-fourdifferent ECC codewords 620 may be streamed in parallel (as opposed tostreaming a single ECC codeword 620 as in the horizontal arrangementexample). Moreover, since each column may be independently addressable,each transferred logical page may comprise data of a separate request(e.g., may represent data of twenty-four different read requests).However, since each ECC codewords is arranged vertically, the streamtime Ts for an ECC codeword 620 may be increased; the stream time of 240byte ECC codewords 620 in a vertical configuration may be 240 cycles, asopposed to 10 cycles in the fully horizontal layout of FIGS. 6A and 6B.The TOPS metric for a single ECC codeword 620, therefore may berepresented as:

$\begin{matrix}{{IOPS}_{r} = \frac{1}{\left( {T_{r} + {240*S_{c}}} \right)}} & {{Eq}.\mspace{14mu} 3}\end{matrix}$

The reduced TOPS metric may be offset by the increased throughput(reduced read overhead) and/or different Tr and Ts latency times. Theseconsiderations may vary from device to device and/or application toapplication. Moreover, the TOPS metric may be ameliorated by the factthat multiple, independent ECC codewords 620 can be streamedsimultaneously. Therefore, in some embodiments, the data layout used bythe storage module 130 (and adaptive write module 248) may beconfigurable (e.g., by a user setting or preference, firmware update, orthe like).

As disclosed above, in some embodiments, the adaptive write module 248may be configured to layout and/or arrange data in an adaptive channelconfiguration. As used herein, an adaptive channel configuration refersto a data layout in which the columns 118 of the array 115 are dividedinto a plurality of independent channels, each channel comprising a setof columns 118 of the solid-state storage array 115. The channels maycomprise subsets of the solid-state storage elements 116A-Y. In someembodiments, an adaptive channel configuration may comprise a fullyhorizontal data layout, in which data segments are stored within achannel comprising 24 columns 118 of the array 115, as disclosed inconjunction with FIGS. 6A and 6B. In other embodiments, the adaptivechannel configuration may comprise a vertical configuration, in whichdata segments are stored within one of 24 different channels, eachcomprising a single column 118 of the array 115, as disclosed inconjunction with FIGS. 6C and 6D. In other embodiments, the adaptivestorage module 248 may be configured to store data in other adaptivechannel configurations and/or layouts on the solid-state storage array115. FIG. 6E depicts another embodiment of a system 604 for adaptivedata storage. In the FIG. 6E embodiment, the adaptive storage module 113is configured to store data structures adaptive channels comprising twosolid-state storage elements 116A-Y (two independent columns 118 perchannel). Accordingly, data segments may be stored within two columns118 of the array. In the FIG. 6E embodiment, the adaptive write module248 may be configured to buffer twelve (12) ECC codewords 620 to streamto the array 115. Each of the twelve ECC codewords 620 may stream to arespective set of two columns 118 within the array 115.

In alternative adaptive channel configurations, the adaptive writemodule 248 may be configured to buffer 24/N ECC codewords 620, where Ncorresponds to the configuration of the adaptive channels used for eachECC codeword 620. ECC codewords 620, may be stored within channelscomprising N independent columns 118. Accordingly, the horizontalarrangement of FIGS. 6A and 6B could be referred to as an adaptivechannel configuration comprising 24 column channels, and the verticaldata structure configuration of FIGS. 6C and 6D may be referred to as anadaptive channel configuration comprising single column channels. Theadaptive storage module 113 may be configured to arrange data in anysuitable hybrid arrangement, including heterogeneous virtual columns.For example, the adaptive write module 248 may be configured to buffersix (6) ECC codewords 620 in a four (4) column adaptive channelconfiguration (e.g., store ECC codewords 620 across each of four (4)columns), buffer four (4) ECC codewords 620 in a six (6) column adaptivechannel configuration (e.g. store ECC codewords 620 across each of six(6) columns), and so on.

In some embodiments, data structures may be arranged in adjacent columns118 within the array 115 (e.g., a data structure may be stored incolumns 0-4). Alternatively, columns may be non-adjacent and/orinterleaved with other data structures (e.g., a data structure may bestored on columns 0, 2, 4, and 6 and another data structure may bestored on columns 2, 3, 5, and 7). The adaptive write module 248 may beconfigured to adapt the data arrangement to out-of-service conditions;if a column 118 (or portion thereof) is out of service, the adaptivestorage module 113 may be configured to adapt the data arrangementaccordingly (e.g., arrange data to avoid the out of service portions ofthe array 115, as disclosed above).

FIG. 6E depicts an embodiment of data layout within channels comprisingtwo column of the array 115 (e.g., two solid-state storage elements116A-X per channel). Accordingly, each data row 667 may comprise twobytes of each of twelve different ECC codewords 620 and a correspondingparity byte. The data row 667 may comprise two bytes of ECC codeword621, two bytes of ECC codeword 622, two bytes of ECC codeword 623, andso on. On each cycle of the bus 127, two bytes of each ECC codeword 620(e.g., ECC codewords 621, 622, 623, 629, and so) on are transferred toprogram buffers of respective solid-state storage elements 116A-X. Dataof the ECC codeword D 621 may be streamed to a first channel comprisingcolumns 0 and 1 (solid-state storage elements 116A-B), the ECC codeword622 may be streamed to a second channel comprising columns 2 and 3(solid-state storage elements 116C-D), the ECC codeword 623 may bestreamed to a third channel comprising columns 4 and 5 (solid-statestorage elements 116E-F), the ECC codeword 629 may be streamed to a lastchannel comprising columns 22 and 23 (solid-state storage elements116W-X), and so on.

FIG. 6F depicts one embodiment 605 of a data structure configuration forthe two column channel embodiment of FIG. 6E. As illustrated in FIG. 6F,data of ECC codeword D 621 may be stored within a channel comprisingcolumns 0 and 1, data of ECC codeword 0 622 may be stored within achannel comprising columns 2 and 3, data of ECC codeword Q 623 may bestored within a channel comprising columns 4 and 5, and so on. FIG. 6Ffurther depicts a data row 667. The data row 667 of FIG. 6F may includetwo bytes of each of twelve different ECC codewords D, O, Q . . . Y, andZ. The data row 667 may further comprise a parity byte 668 correspondingto the contents of the data row 667, as disclosed above.

The stream time Ts of an ECC codeword 620 in the FIG. 6E embodiment maybe 120 cycles of the bus 127 (e.g., 240/N cycles). An TOPS metric of thetwo (2) column hybrid arrangement of FIG. 6E may be represented as:

$\begin{matrix}{{IOPS}_{r} = \frac{2}{\left( {T_{r} + {120*S_{c}}} \right)}} & {{Eq}.\mspace{14mu} 4}\end{matrix}$

The TOPS metric may be modified according to a number of data structuresthat can be read in parallel. The two-column channel configuration ofFIG. 6E may enable 12 different ECC codewords (and/or packets) to beread from the array 115 concurrently.

The adaptive data structure configurations disclosed herein may affecterror detection and/or data recovery operations. In a horizontal dataalignment, data of each ECC codeword 620 may be spread across thecolumns 118 of the array 115 (e.g., ten bytes on each of twenty foursolid-state storage elements 116A-X). Therefore, if an uncorrectable ECCerror is encountered, identifying the source of the error may compriseperforming an iterative parity substitution across each of the twentyfour storage elements 116A-X (e.g., reconstruct the ECC codeword 620from parity data while omitting data of a respective storage element116A-X until the source of the error is identified). Moreover, since theECC codewords 620 cannot be corrected until data of the failed column isrecovered, parity reconstruction may aggregate errors in other columns118.

By contrast, when data is arranged vertically as in FIGS. 6C and 6D, thesource of the error may be immediately determined without iterativeparity substitution; since all of the data of the ECC codeword 620 isstored within a single solid-state storage element 116A-X, failure tovalidate an ECC codeword 620 by the ECC read module 245 indicates thatthe corresponding column 118 within the array is the source of theuncorrectable error.

As disclosed above, a suitable data arrangement may be selected, atleast in part, based upon the ECC algorithm in use (e.g., the size ofthe ECC codewords 620, ratio between data and syndrome, and so on). Insome embodiments, the adaptive storage module 113 may be configured toimplement a symbolic ECC algorithm. For example, the ECC write module246 may be configured generate ECC symbols (e.g., 8 bit ECC symbols),which may be individually streamed to solid-state storage array 115, asdisclosed herein. Since the ECC symbols each fall within a singlecolumn, the adaptive storage module 113 may be configured to arrange theECC symbols in any of the horizontal, vertical, and/or hybridarrangements described above. Alternatively, or in addition, the dataarrangement may be selected according to other data structures withinthe ECC symbols, such as packets 610, or the like. For example, an ECCsymbol arrangement may be configured to store ECC symbols of a packet610 horizontally, vertically, and/or in a hybrid arrangement, asdescribed above. Other ECC symbol sizes (e.g., 16 bit symbols, 32 bitsymbols, and so on), may be arranged according to a horizontal,vertical, and/or hybrid arrangement, as disclosed herein.

In some embodiments, vertical data structure configuration may providebenefits for data reconstruction. In particular, vertical data structurelayout and/or arrangement may avoid error aggregation issues. Referringback to FIG. 6D, the data recovery module 170 may be configured toreconstruct data of a vertically arranged ECC codeword 620 by readingECC codewords 620 on other columns 118 of the array 115, correctingerrors in the other ECC codewords 620 (if any) by, inter alia, decodingthe other ECC codewords 620 using the ECC read module 245, and using thecorrected and/or decoded ECC codewords and parity data of column 24 toreconstruct the ECC codeword 620 within the failed column 118. Use ofcorrected and/or decoded ECC codewords, as opposed to portions ofuncorrected ECC codeword data 620, may prevent errors from beingaggregated and/or included in the reconstructed ECC codeword.

In the FIG. 6D data structure configuration, if column 0 comprising ECCcodeword D 621 fails, such that the ECC codeword D 621 cannot be readfrom the array, the reconstruction module 170 may be configured toreconstruct the ECC codeword 621 by: reading ECC codewords O through Zfrom columns 1 through 23 (and parity data of column 24); correctingerrors in the ECC codewords O through Z (if any) by use of the ECC readmodule 245; and reconstructing data of the ECC codeword D 621 using thecorrected ECC codewords O through Z and the parity data of column 24.Accordingly, the data used to correct ECC codeword D 621 (ECC codewordsO through Z) may be free from correctable errors, and as such, sucherrors may not be reflected in the reconstructed data comprising ECCcodeword D 621.

Hybrid, independent channel data structure layouts may provide similarbenefits. For example, identifying errors in a two (2) column hybrid mayonly require iterative substitution between two (2) columns, errors in afour (4) column hybrid may only require iterative substitution betweenfour (4) columns, and so on. Referring back to FIG. 6F, identifying thesource of an uncorrectable error in the ECC codeword D 621 may compriseiterative parity substitution between two columns 0 and 1.

Hybrid, independent channel configurations may also benefit from reducederror aggregation during data reconstruction. Referring to the twocolumn channel embodiment of FIGS. 6E and 6F, ECC codewords 620 may bestored within channels comprising two columns 118 of the array 115.Accordingly, reconstructing data of a failed column of one of thechannels may comprise reading data of other ECC codewords 620 on othercolumns of the array 115, correcting errors within the other ECCcodewords 620 (if any), and using the corrected ECC codewords 620, dataof the valid column of the channel, and the parity data to reconstructdata of the failed column 118. For example, reconstructing data offailed column 0 comprising ECC codeword D 621 may comprise: reading dataof ECC codewords O through Z on columns 2 through 23, correcting errorswithin the ECC codewords 622, 623, through 629 (if any) by use of theECC read module 245; and reconstructing data of column 0 by use of dataread from column 1, the corrected ECC codewords of columns 2 through 23,and the parity data of column 24. The only source of potentialuncorrected errors is the other columns within the channel with thefailed column 0 (column 1). Accordingly, data reconstructing in theFIGS. 6E and 6F embodiment incorporates errors from only a singlecolumn, as opposed to aggregating errors from 23 other columns as in thehorizontal data structure layout of FIGS. 6A and 6B.

The size of the data structures, such as the ECC codewords 620 and/orpackets 610, may be adapted according to the data arrangementimplemented by adaptive write module 248. For example, the size of theECC codewords 620 may be selected to minimize wasted overhead when ECCcodewords 620 are stored in a horizontal arrangement on twenty fourstorage elements 515. However, in other data arrangement embodiments,other data structure sizes may be selected. For example, in the verticallayout of FIGS. 6C and 6D, the size of the ECC codeword 620 may beadapted according to the “depth” of the columns (e.g., the page size ofeach solid-state storage element). Hybrid, independent channelconfigurations may involve similar sizing considerations. In someembodiments, the size of the ECC codewords 620 (e.g., the ratio of datato syndrome) may be used to determine a suitable data arrangement. Forexample, given a particular ECC codeword size, a data arrangement thatminimizes wasted overhead, while providing an acceptable TOPS metric,may be identified based on, inter alia, the depth of physical storageunits of the solid-state storage medium 110.

Table 1 illustrates various configurations of adaptive channel datalayout embodiments used with different data structure sizes (240 and 960byte ECC codewords 620), as disclosed herein:

Independent T_(s): 240 T_(s): 960 Channels, Byte Data Byte Data AdaptiveData Configuration Codewords/Read Structures Structures 1 of 24(vertical, FIGS. 6C 1 240 960 and 6D) 2 of 12 (hybrid, FIGS. 6E 2 120480 and 6F) 3 of 8 3 80 320 4 of 6 4 60 240 2 of 3 and 3 of 6 5 48 192 6of 4 6 40 160 4 of 3 and 3 of 4 7 34 137 8 of 3 8 30 120 4 of 3 and 5 of2 and extra 9 27 107 2 of 1 4 of 3 and 6 of 2 10 24 96 4 of 3 and 5 of 2and 2 of 1 11 22 87 12 of 2 12 20 80 4 of 3 and 3 of 2 and 6 of 1 13 1874 4 of 3 and 2 of 2 and 8 of 1 14 17 69 4 of 3 and 1 of 2 and 10 of 115 16 64 4 of 3 and 12 of 1 16 15 60 3 of 3 and 14 of 1 and extra 17 1456 1 of 1 3 of 3 and 15 of 1 18 13 53 2 of 3 and 18 of 1 20 12 48 1 of 3and 20 of 1 and extra 21 11 46 1 of 1 1 of 3 and 21 of 1 22 11 44 1 of 2and 22 of 1 23 10 42 24 of 1 (horizontal, FIGS. 6A 24 10 40 and 6B)

As disclosed herein, storage of data structures in verticalconfigurations may improve error detection, error correction and/or datareconstruction performance. However, horizontal storage configurationsmay provide performance benefits in certain situations (e.g., reducestream time). Accordingly, in some embodiments, the storage module maybe configured to store data structures in an adaptive vertical stripeconfiguration. As used herein, a vertical stripe configuration refers tostoring data structures vertically within vertical stripes having apredetermined depth. Multiple vertical stripes may be stored within rows117 of the array 115. The depth of the vertical stripes may, therefore,determine read-level parallelism, whereas the vertical ECC configurationmay maximize error detection, correction, and/or reconstructionbenefits.

FIG. 6G depicts one embodiment of a vertical stripe data configuration606 within a logical page 542 (row 117) of a solid-state storage array115. As disclosed above, a vertical stripe may comprise verticallyarranged data structures within respective columns 118 of the array 115.The vertical stripes 646A-N have a configurable depth or length. In theFIG. 6G embodiment, the vertical stripes 646A-N are configured to have adepth sufficient to store four ECC codewords. In some embodiments, thedepth of the vertical stripes 646A-N corresponds to an integral factorof ECC codeword size relative to a page size of the solid-state storagemedium 110.

In the FIG. 6G embodiment, the page size of the solid-state storagemedium 110 may be 16 kb, each page may be configured to hold fourvertical stripes 646A-N, and each vertical stripe may be configured tohold four 1 kb vertically aligned ECC codewords. The disclosedembodiments are not limited in this regard, however, and could beadapted to use any solid-state storage medium 110 having any page sizein conjunction with any ECC codeword size and/or vertical stripe depth.

The depth of the vertical stripes 646A-N and the size of typical readoperations, may determine, inter alia, the number of channels (columns)needed to perform read operations (e.g., determine the number ofchannels used to perform a read operation, stream time Ts, and so on).For example, a 4 kb data packet may be contained within 5 ECC codewords,including ECC codewords 3 through 7. Reading the 4 kb packet from thearray 115 may, therefore, comprise reading data from two columns(columns 0 and 1). A larger 8 kb data structure may span ten ECCcodewords (ECC codewords 98-107), and as such, reading the 8 kb datastructure may comprise reading data from three columns of the array(columns 0, 1, and 2). Configuring the vertical stripes 646A-N with anincreased depth may decrease the number of columns needed for a readoperation, which may increase the stream time Ts for the individualread, but may allow for other independent read operations to beperformed in parallel. Decreasing depth may increase the number ofcolumns needed for read operations, which may decrease stream timeT_(s), but result in decreasing the number of other, independent readoperations that can be performed in parallel.

FIG. 6H depicts embodiments of vertical stripes 607, each having adifferent respective depth. The vertical stripes 607 may comprise 1 kb,vertically aligned ECC codewords as disclosed above in conjunction withFIG. 6G. A 16 kb data structure 610 (packet) may be stored within a 4 kdeep vertical stripe 746. The data structure 610 may be contained withinseventeen separate ECC codewords spanning five columns of the array 115(columns 0 through 5). Accordingly, reading the data structure 610 maycomprise reading data from an independent channel comprising sixcolumns. The stream time Ts of the read operation may correspond to thedepth of the vertical stripe 746A (e.g., the stream time of four ECCcodewords).

The depth of the vertical stripe 746B may be increased to 8 kb, whichmay be sufficient to hold eight vertically aligned ECC codewords. Thedata structure 610 may be stored within seventeen ECC codewords, asdisclosed above. However, the modified depth of the vertical stripe 746Bmay result in the data structure occupying three columns (columns 0through 2) rather than six. Accordingly, reading the data structure 610may comprise reading data from an independent channel comprising threecolumns, which may increase the number of other, independent readoperations that can occur in parallel on other columns (e.g., columns 3and 4). The stream time Ts of the read operation may double as comparedto the stream time of the vertical stripe 746A.

FIG. 6I is a block diagram of another embodiment of a system 608 foradaptive data storage. In the FIG. 6I embodiment, the adaptive writemodule 248 may be configured to store data in a vertical stripeconfiguration within logical pages 542 of the solid-state storage array115. The write module 240 may comprise one or more processing modules,which as disclosed above, may include, but are not limited to: a packetmodule 242, a whiten module 244, and an ECC write module 246. The ECCwrite module 246 may be configured to generate ECC codewords 620 (ECCcodewords O through Z) in response to data for storage on thesolid-state storage array 115, as disclosed above. The ECC codewords 620may flow into the adaptive write module 248 serially via a 128 bit datapath of the write module 240. As disclosed in further detail herein, theECC write module 246 may further comprise a relational module 646configured to include relational information in one or more of the ECCcodewords 620.

The adaptive write module 248 may be configured to buffer the ECCcodewords 620 for storage in vertical stripes, as disclosed herein. Theadaptive write module 248 may comprise an adaptive fill module 660 thatis configured to rotate the serial stream of ECC codewords 620 intovertical stripes by use of, inter alia, one or more cross pointswitches, FIFO buffers 662A-X, and the like. The FIFO buffers 662A-X mayeach correspond to a respective column of the array 115. The adaptivefill module 660 may be configured to rotate and/or buffer the ECCcodewords 620 according to a particular vertical code word depth, whichmay be based on the ECC codeword 620 size and/or size of physicalstorage units of the array 115.

The adaptive write module 248 may be further configured to manage OOSconditions within the solid-state storage array 115. As disclosed above,a OOS condition may indicate that one or more columns 118 of the arrayare not currently in use to store data. The storage metadata 135 mayidentify columns 118 that are out of service within various portions(e.g., rows 117, logical erase blocks 540, or the like) of thesolid-state storage array 115. In the FIG. 6I embodiment, the storagemetadata 135 may indicate that column 2, of the current logical page542, is out of service. In response, the adaptive fill module 660 may beconfigured to avoid column 2 by, inter alia, injecting padding data intothe FIFO buffer of the OOS column (e.g., FIFO buffer 662C).

In some embodiments, the adaptive write module 248 may comprise a paritymodule 637 that is configured to generate parity data in accordance withthe vertical strip data configuration. The parity data may be generatedhorizontally, on a byte-by-byte basis within rows 117 of the array 115as disclosed above. The parity data P0 may correspond to ECC codewords0, 4, through 88; the parity data P1 may correspond to ECC codewords 1,5, through 89, and so on. The adaptive write module 248 may include aparity control FIFO 662Y configured to manage OOS conditions for paritycalculations (e.g., ignore data within OOS columns for the purposes ofthe parity calculation).

The vertical stripe data configuration generated by the adaptive writemodule 248 (and parity module 637) may flow to write buffers of thesolid-state storage elements 116A-Y within the array 115 through thewrite buffer and/or bank controller 252, as disclosed above. In someembodiments, data rows 667 generated by the adaptive write module 247may comprise on byte for each data column in the array 115 (columns116A-X). Each byte in a data row 667 may correspond to a respective ECCcodeword 620 and may include a corresponding parity byte. Accordingly,each data row 667 may comprise horizontal byte-wise parity informationfrom which any of the bytes within the row 667 may be reconstructed, asdisclosed herein. A data row 667A may comprise a byte of ECC codeword 0for storage on column 0, a byte of ECC codeword 4 for storage on column1, padding data for column 1, a byte of ECC codeword 88 for storage oncolumn 23, and so on. The data row 667 may further comprise a paritybyte 668A for storage on column 24 (or other column), as disclosedabove.

The data may be programmed unto the solid-state storage array 115 as aplurality of vertical stripes 646A-N within a logical page 542, asdisclosed above (e.g., by programming the contents of program buffers tophysical storage units of the solid-state storage elements 116A-Y withinthe array 115). In the FIG. 6I embodiment, the indexing S*N maycorrespond to vertical stripes configured to hold S ECC codewords in anarray 115 comprising N columns for storing data.

As disclosed herein, data structures, such as data packets, may bestored within respective container data structures (ECC codewords),which may be spread across different columns 118 and/or rows 117 of thesolid-state storage array 115. FIG. 6J depicts one embodiment 609 of asolid-state storage array 115 comprising a data structure (packet 810C)that is stored within a plurality of vertical stripes 846A-B. Asillustrated in FIG. 6G, the adaptive write module 248 may be configuredto arrange ECC codewords comprising the data structure 810C, such thatportions of the data structure 810C are stored within the verticalstripe 846A and other portions are stored in a different vertical stripe846B (ECC codewords comprising the packet 810C may wrap betweendifferent vertical stripes). In addition, portions of the data structure810C may be stored on different rows 117 of the array 115 (e.g., withindifferent logical pages 542A and 542B). In some embodiments, datastructure 810C may span logical erase blocks and/or banks 119A-N; thelogical page 542A may be within a different logical storage division 540and/or different bank 119A-N than the logical page 542B. Moreover,header information stored with the data structures (e.g., headers 814A,814B, and/or 814C) may be stored in separate ECC codewords than otherportions of the corresponding packets 812A, 812B, and/or 812C).

In some embodiments, the ECC codewords comprising a particular datastructure (e.g., data structure 810) may comprise relationalinformation, which may allow the storage module to verify that differentECC codewords read from various different portions of the array 115correspond to the same data structure 810C, despite the fact that theheader information is distributed between different ECC codewords storedon different portions of the array 115. Referring back to FIG. 6I, theECC write module 246 may comprise a relational module 646 configured toinclude relational information in the ECC codewords 620 generatedthereby. The relational information may be configured to provide foridentifying and/or verifying that certain ECC codewords 620 are related(e.g., provide for verifying that particular ECC codewords 620 comprisedata of the same data structure 810C). The relational information maycomprise any identifying data. In some embodiments, the relationalinformation may be derived from the header 814C of the packet, such asthe logical identifier(s) associated with the data structure 810C. Therelational information pertaining to data structures processed by theECC write module 646 may, therefore, be determined based on storagemetadata 135 associated with the data, header information, or the like.

The relational module 646 may be configured to mark the ECC codewords620 with relational information in any suitable format and/or using anysuitable mechanism. Marking may comprise adding information to the ECCcodewords 620 (e.g., in one or more fields, etc.). In some embodiments,the relational module 646 may be configured to mark ECC codewords 620through Steganography and/or watermarking. Watermarking may compriseperforming an XOR operation between relational information (e.g., abitmask of one or more logical identifier(s) associated with thecorresponding data structure) and the ECC codewords 620. As disclosedherein, an ECC datastructure 620 may comprise portions of multipledifferent data structures; such ECC codewords 620 may include relationalinformation associated with each data structure contained therein.Accordingly, in some embodiments, the relational module 646 may beconfigured to mark an ECC codeword 620 with multiple instances ofrelational information (e.g., multiple watermarks).

FIG. 6K is a block diagram of another embodiment of a system 610 foradaptive data storage. The system 610 illustrates one embodiment of aread module 241 configured to read data stored in a vertical stripeconfiguration on a solid-state storage array 115. The read module 241may comprise an adaptive read module 247 configured to read data fromrows of the array 115 (e.g., read data stored in vertical stripes 646A-Nwithin logical pages 542 of the array 115). Data may be read into a readbuffer 251 by use of the bus 127, bank controller 252, and/or logstorage module 137.

The adaptive read module 247 may comprise an adaptive strip module 661configured to remove and/or avoid data of columns that are OOS (based onthe storage metadata 135, as disclosed above), which may compriseremoving the data from an incoming data stream by use of a cross-pointswitch, or the like.

The read sequence module 663 may be configured to reorder and/orrecombine ECC codewords 620 in sequence, which may comprise rotatingvertical stripes read from the array 115 by use of respective buffers665A-Y, as disclosed above (e.g., rotating and combining ECC codewordsread from respective columns 118 of the array 115). The sequenced ECCcodewords 620 may flow to other processing modules of the read module241.

In some embodiments, the ECC read module 245 may comprise a relationalverification module 647 configured to verify relational information onthe ECC codewords 620 (e.g., verify and/or authenticate one or moremarkings on the ECC codewords 620). Verifying relational information mycomprise performing an XOR operation between the ECC codewords 620 andrespective logical identifier(s) associated with the data structurescontained therein. Verifying relational information of an ECC codeword620 that comprises portions of multiple packets may comprise performingmultiple XOR operations, each corresponding to logical identifier(s) ofa packet contained therein. The logical identifier information used toperform relational verification may be received via the storage metadata135 and/or as part of a read request. In some embodiments, requests toread data on the solid-state storage array 115 may be accompanied by thelogical identifier(s) associated with the request, which may betranslated into physical addresses by use of, inter alia, the storagemetadata 135. This logical identifier information may be used to performrelational verification on the corresponding ECC codewords 620. Thelogical identifier(s) of other data structures within a particular ECCcodeword 620 that are not part of the read request (if any) may bedetermined by use of, inter alia, a reverse index, or the like, of thestorage metadata 135.

If the relational verification module 647 fails to verify relationalinformation of an ECC codeword 620, the solid-state adaptive storagemodule 113 may issue an interrupt, indicating that the data could not beread. In response, the data reconstruction module 170 may attempt toacquire the data from another source and/or from another portion of thesolid-state storage array 115. In embodiments in which the relationalmodule 645 watermarks ECC codewords 620 with logical identifierinformation, the relational verification module 647 may be configured toverify the relational information may performing an equivalent XORoperation. If the relational information differs between the XORoperation performed during storage and the XOR operation performed whenthe data is read, the corresponding ECC codeword(s) 620 may becorrupted, and the ECC read module 245 will detect uncorrectable errorsthere; in response, the storage module 130 may issue a read failureinterrupt, as disclosed above.

FIG. 6L depicts one embodiment of data flow 611 of a read sequenceoperation. The data flow 611 depicted in FIG. 6L may be implemented bythe adaptive read module 247 as disclosed herein. Referring to FIG. 6J,storage module 130 may receive requests to read data packets 810A, 810B,and 810C. The read sequence module 663 and/or log storage module 137 mayconfigure the adaptive storage module 113 to read data from the columns118 comprising the requested data (by use of the logical-to-physicaltranslation layer 132). The adaptive storage module 113 may beconfigured to read the data packets 810A, 810B, and 810C in a singleread operation on the array 115, which may comprise providing differentaddressing information to different sets of columns 118. In the FIG. 6Jembodiment, columns 0 and 1 may be configured to read data from logicalpage 542B, column 2 may be configured to read data from logical page542A, columns 3 and 4 may be configured to read data from logical page542N, and columns 21-23 may be configured to read data from logical page542A. The different addressing information may be sent to theindependent columns 118 via the bus 127, as disclosed above.

The read operation may comprise transferring the contents of thespecified logical pages into the read buffer 251. FIG. 6L depicts oneembodiment of a read buffer comprising data of packets 810A, 810B, and810C. Columns 0 through 23 of the of the buffer 251 may correspond tocolumns 118 of the array 115 and, as such, may comprise data read fromread buffers of the respective solid-state storage elements 116A-Ycomprising the array 115. The contents of columns 5 through 20 are notshown in FIG. 6L to avoid obscuring the details of the depictedembodiment. These columns could, however, comprise data corresponding toother data structures, OOS mask data, or no-op data, read from thecorresponding solid-state storage elements 116F-V.

The read sequence module 663 may be configured to determine whichportions of the buffer 251 comprise valid data (based on thelogical-to-physical translation information, OOS metadata, and so on),and may reorder and/or mask the contents of the read buffer 251 togenerate a sequence of ECC codewords 620 comprising the requested data.The read sequence module 663 may be further configured to order the datastructures in accordance with an order of the request requests within,inter alia, the request buffer 136. The ECC codeword sequence 622 maycomprise an ordered sequence of ECC codewords 622A comprising datastructure 810A, followed by the ECC codewords 622B comprising datastructure 810B, and the ECC codewords 622C comprising data structure810C. As illustrated in FIG. 6C, the contents of columns 0 and 1 oflogical page 542B (ECC sequence 622C-1) may be ordered after thecontents of columns 21-23 (ECC sequence 622C-2) in the sequence 622.

Referring back to FIG. 1, the storage module 130 may comprise a requestbuffer 136 configured to receive storage requests from one or morestorage clients 104. The storage requests may be queued in the requestbuffer 136, and serviced and/or executed by the storage module 130. Insome embodiments, the storage module 130 comprises an adaptive schedulemodule 114 configured to determine an optimal schedule for storageoperations based on, inter alia, the adaptive data configuration on thesolid-state storage array 115. As used herein, an “optimal” schedulerefers to a schedule that maximizes an objective criteria. In someembodiments, the objective criteria may be maximization of parallelismwhile maintaining data ordering constraints and/or avoiding hazards,such as read before write, write before read, or the like.

FIG. 7 depicts one embodiment of adaptive scheduling performed by theadaptive schedule module 114. The adaptive schedule module 114 may beconfigured to schedule storage operations in accordance with theadaptive configuration of data structures on a solid-state storage array115. As illustrated in FIG. 7, an ordered sequence of requests to readpackets A, B, C, D, E, and F may be received at the storage module andbuffered in the request buffer 136. The adaptive schedule module 114 maybe configured to analyze the requests in the buffer 136, determine alayout of data corresponding to the requests on the solid-state storagearray 115, and to combine and/or schedule the requests to maximize readparallelism, while avoiding data hazards.

The adaptive schedule module 114 may determine that the read requestscorrespond to the data layout depicted in FIG. 7, by use of, inter alia,the logical-to-physical translation layer 132 and storage metadata 135.The adaptive schedule module 114 may be further configured to identifycolumn and/or channel conflicts between read requests, which maycomprise identifying which read requests require use of columns that areneeded by other read requests. As illustrated in FIG. 7, data packets710A-F stored within overlapping columns of the array 115 may beconsidered to conflict with respect to read scheduling. In the FIG. 7embodiment data packets 710A overlaps with (conflicts with) packet 710B,packet 710B overlaps with packet 710A and 710C, packet 710E overlapswith packet 710D and 710F, and so on. The adaptive schedule module 114may identify channel conflicts by use of column bitmaps, or othertechnique. The adaptive schedule module 114 may be further configured toidentify read requests that can be performed in parallel (e.g., readrequests that do not conflict and/or require access to the same columnsof the array 115). Non-conflicting read requests may be combined and/oraggregated into a single, composite read request. In the FIG. 7embodiment, the requests to read packets A, C, E, and F may be combinedinto a single read operation 761. The requests to read packets B and Dmay combined into another read operation 762. Data of the readoperations 761 and 762 may be processed by the read module 241, whichmay comprise reordering, ECC decoding, dewhitening, and/or depacketizingthe data, as disclosed herein. As illustrated in FIG. 7, the combinedread requests may change the order of read operations (perform the readof packets C, E, and F before packet B). The adaptive schedule module114 may be configured combine, schedule and/or reorder operations toprevent data hazards, such as read-before-write and/or write-beforewrite. Alternatively, the adaptive schedule module 114 may be configuredto maintain the order of the requests in the buffer 136, which may limitthe degree of parallelism that can be achieved through requestscheduling and aggregation.

As disclosed herein, errors within ECC codewords may be detected and/orcorrected by the ECC read module 245 as data is read from thesolid-state storage array 115. Some ECC codewords, however, may comprisemore errors than can be corrected by the ECC algorithm. As disclosedabove, in response to detecting an uncorrectable ECC codeword, theadaptive storage module 113 may issue an interrupt to the data recoverymodule 170, which may attempt to recover the data using, inter alia,parity data stored on the solid-state storage array. In some cases,uncorrectable errors may be cause by the failure of a portion of thesolid-state storage array 115. Such errors may occur within specificcolumns, and as such, error conditions may result in losing the data ofportions of a column 118 within the array 115.

FIG. 8 is a block diagram of one embodiment of a system 800 forreconstructing data stored on a failed column of a solid-state storagearray 115 using, inter alia, parity substitution. Data of packet 910Amay be read from the array 115 in a read operation. Data of the packet910A may be stored within vertical stripe 946B. The read operation 961may include reading other data packets 910B and 910C within otherlogical pages 946A and 946N. Data of the other packets 910B and 910C maynot comprise uncorrectable errors, and may be processed through the readmodule 241, as disclosed above.

The ECC codewords in column 0 of the vertical stripe 946B, comprisingdata of packet 910A, may comprise errors that cannot be corrected by theECC read module 245. In response, the adaptive storage module 113 mayissue an interrupt to the data reconstruction module 170. The datareconstruction module 170 may be configured to determine the source ofthe uncorrectable error by use of the logical-to-physical translationlayer 132, and to reconstruct data of column 0 in the vertical stripe946B by use of, inter alia, other ECC codewords and/or the parity datastored within the vertical stripe 946B.

The data reconstruction module 170 may be configured to issue anotherread operation 962 to read the other ECC codewords 919 within thevertical stripe 946B. The read operation 962 may further comprisereading parity data 947B of the vertical stripe 946B. The data acquiredin the read operation 962 may be processed by the adaptive read module248, which may comprise stripping padding data (if any) from the readbuffer 251, as disclosed above. The ECC read module 245 may beconfigured identify and/or correct errors in the ECC codewords 910A and919, which may comprise decoding the ECC codewords 910A and 919 and/orgenerating corrected ECC codewords 920A and 929.

The data reconstruction module 170 may comprise a parity substitutionmodule, which may be configured to reconstruct the ECC codewords 911A-Nin column 0 by use of the corrected ECC codewords 920A-N correspondingto columns 1 through 10, corrected ECC codewords 929A-N corresponding tocolumns 11-23, and parity data 947A-N: ECC codeword 911A may bereconstructed by use of corrected ECC codewords 920A[1 through 10],corrected ECC codewords 929A[11 through 23], and parity data 947A, ECCcodeword 911B may be reconstructed by use of corrected ECC codewords920B[1 through 10], corrected ECC codewords 929B[11 through 23], andparity data 947B, and so on. As disclosed above, use of the correctedECC codewords 919A-N and 929A-N may prevent error aggregation duringparity substitution operations.

In some embodiments, parity substitution module 172 may be configured toperform a byte-wise parity substitution operation corresponding to thebyte-wise parity generation embodiments disclosed in conjunction withFIGS. 6A-6F, 6I and 6K. Following reconstruction of the ECC codewords ofcolumn 0, data packet 910A may processed by the read module 241 andreturned to the requester, as disclosed herein, which may comprisediscarding the other ECC codewords 919 and 929 read from the verticalstripe 946B.

FIG. 9 is a flow diagram of one embodiment of a method 900 for adaptivedata storage. The method 900, and the other methods disclosed herein,may comprise steps configured for execution by a machine, such as acomputing device 101, storage module 130, and/or adaptive storage module113 as disclosed herein. Steps of the disclosed methods may be embodiedas a computer program product, including a computer-readable storagemedium comprising instructions configured for execution by a computingdevice to perform one or more method steps.

The method 900 may start and/or be initialized, which may compriseinitializing communication resources, loading computer-executableinstructions, and so on.

Step 920 may comprise arranging data for storage on a solid-statestorage array 115. The solid-state storage array 115 may comprise aplurality of independent columns 118 (e.g., solid-state storage elements116A-Y), which may be communicatively coupled to a adaptive storagemodule 113 in parallel by, inter alia, a bus 127.

In some embodiments step 920 may further comprise generating datastructures for storage on the array 115. Step 920 may comprisegenerating one or more packets 310 comprising data for storage on thearray 115, by use of a packet module 242. The packets 310 may comprisecontextual metadata pertaining to the data, such as one or more logicalidentifiers associated with the data, and so on, as disclosed above.Step 920 may further comprise whitening the data packets, by use of awhiten module 244. Step 920 may comprise generating one or more ECCcodewords comprising the packets. The ECC codewords may comprise ECCcodewords, ECC codewords, ECC symbols, or the like. In some embodiments,step 920 further comprises including relational information in the ECCcodewords, which may comprise watermarking the ECC codewords within abitmask (or other data) derived from a logical identifier associatedwith the data packets.

Arranging the data at step 920 may comprise buffering one or more datastructures, such that the data structures layout within portions of thesolid-state storage array 115. Arranging the data structures at step 920may, therefore, comprise configuring the data structures to layout in ahorizontal, vertical, and/or hybrid configuration within the solid-statestorage array 115. Step 820 may comprise a 24 byte by 10 byte buffer ofthe horizontal embodiment of FIG. 6A. Alternatively, step 920 maycomprise arranging the data structures for a vertical data structurelayout, as disclosed in conjunction with FIG. 6C; step 920 may compriseusing a buffer capable of buffering 24 240 byte ECC codewords 620 (orother data structures) for storage on respective columns of the logicalstorage element. Step 920 may further comprise arranging the datastructures in a hybrid, independent channel configuration as disclosedin conjunction with FIG. 6E; step 920 may comprise buffering datastructures in a write buffer capable of buffering 24/N 240 byte ECCcodewords 620 data structures where N is the number of independentcolumns of the hybrid storage arrangement. The data structures maycomprise ECC codewords 620. The arrangement of step 920 may compriseconfiguring data of the same ECC codeword for storage on two of moredifferent independent columns 118 of the array 115. Alternatively, thearrangement of step 920 may comprise configuring data of the ECCcodewords for storage within respective columns 118 of the array 115.

Alternatively, or in addition, buffering the data structures at step 920may comprise configuring the data structures to layout within verticalstripes of the solid-state storage array 115. Step 920 may comprisebuffering the data in accordance with a selected vertical stripe depthand/or length, which may correspond to an integral factor of datastructures and/or page size of the solid-state storage medium 110. Step920 may, therefore, comprise streaming ECC codewords 620 into verticalFIFO buffers 662A-X as disclosed in conjunction with FIG. 6I. Thevertical stripe configuration may comprise storing ECC codewords 620within respective columns 118 of the array 115. However, data structurescontained within the ECC codewords 620 (e.g., packets) may be configuredfor storage on two or more different columns 118.

In some embodiments, step 920 further comprises adapting the data layoutto avoid portions of the array 115 that are out of service. Step 920 maycomprise injecting padding data into the buffer(s) to mask 00S columns118 of the array (in accordance with the storage metadata 135), asdisclosed above.

Step 930 may comprise streaming the data arranged at step 920 to thesolid-state storage array 115, as disclosed above. Step 830 may comprisebyte-wise streaming bytes to program buffers of a plurality ofindependent columns 118 of the array 115. Step 930 may further comprisegenerating byte-wise parity information for storage on a parity columnof the array 115, as disclosed above.

Step 940 may comprise programming the contents of the program buffersstreamed at step 930 onto a logical page of the solid-state storagearray 115. Step 940 may comprise issuing a program command to thesolid-state storage array 115 via the bus 127. In response to thecommand, each of the plurality of independent columns 118 of the arraymay be configured to perform a program operation concurrently and/or inparallel with other columns 118 within the array 115. Steps 920-940 mayfurther comprise updating the logical-to-physical translation layer 132to indicate the physical storage locations of the data structures storedon the array 115. The physical storage locations may indicate the bank119A-N, array 115A-N, logical page 542, offset, and the like, of thedata structures. The logical-to-physical translation metadata maycomprise any-to-any associations between logical addresses, such aslogical identifiers, and addresses of physical storage locations withinthe array 115.

FIG. 10 is a flow diagram of another embodiment of a method 1000 foradaptive data storage. The method 1000 may start and/or be initializedas disclosed above.

Step 1010 may comprise determining an adaptive data arrangement for usewithin a solid-state storage array 115. The determination of step 1010may be based on, inter alia, a read time Tr of the solid-state storagemedium 110, a stream time Ts of the adaptive storage module 113, dataaccess characteristics of storage clients 104, desired TOPScharacteristics, data reconstruction characteristics, and so on. Thedetermination of step 1010 may comprise selecting between one or moreof: a) a horizontal data arrangement that reduces stream time Tr, butreduces availability of read-parallelism, b) a vertical data arrangementthat increases read-parallelism, but may increase stream time Tr, c) ahybrid, independent channel configuration, and/or d) a vertical stripeconfiguration having a particular vertical stripe depth.

Step 1010 may comprise generating a profile of data storage operationsby, inter alia, the adaptive storage profiling module 160. As usedherein, profiling data operations refers to gathering information (e.g.,storage metadata 135) pertaining to the storage operations performed bystorage clients 104 through the storage interface 131. Profiling datamay comprise data access patterns, characteristics of the solid-statestorage medium 110, bus 127, and so on, which may be used to determinean optimal adaptive data structure layout on the solid-state storagearray 115. The adaptive storage profiling module 160 may be configuredto gather such profiling information and/or generate recommendationsregarding data layout in response to the profiling information. Forexample, applications that exhibit a large number of data accesses torelatively small data segments and/or packets, may be suited to avertical configuration, a hybrid, independent channel configuration(e.g., 2 or 4 column channel configuration), and/or a vertical stripeconfiguration. In another example, the storage medium 110 may exhibitrelatively high stream times as compared to read times Tr, and as such,a horizontal and/or wide channel configuration may result in improvedperformance.

The determination of step 1010 may be based on data reconstructioncharacteristics of various adaptive data layouts. Over time, thesolid-state storage medium 110 may become less reliable and, as such,data structure configuration that provides better data reconstructionperformance may be preferred over other configurations. For example,highly vertical configurations, including the vertical stripeconfigurations, may reduce error aggregation during parityreconstruction operations as compared to horizontal data layouts and, assuch, may provide improved data reconstruction performance.

In some embodiments, step 1010 may comprise determining an adaptive datalayout by use of an objective function. The objective function may beconfigured to quantify the performance of different adaptive data layoutconfigurations in view of the profiling data gathered by the adaptivestorage profiling module 160 and/or other considerations (e.g., datareconstruction characteristics). The adaptive data configuration thatprovides the highest utility per the objective function may beidentified as the optimal data configuration for the particular set ofprofiling data and/or other considerations.

Step 1010 may further comprise automatically configuring the storagemodule 130 to implement the determined adaptive data arrangement.Alternatively, step 1010 may comprise providing information pertainingto the determined adaptive data arrangement to a user, administrator, orother entity, which may determine whether any changes should beimplemented.

Steps 1020, 1030, and 1040 may comprise arranging data for storage onthe solid-state storage array in accordance with the determined,adaptive data arrangement, streaming the data structures to the array115, and programming the data to the array 115, as disclosed above.

FIG. 11 is a flow diagram of another embodiment of a method 1100 foradaptive data storage. Step 1120 may comprise determining the storagelocation of requested data within the array 115. Step 1120 may comprisedetermining the storage location by use of a logical-to-physicaltranslation layer 132, which may include storage metadata 135, such as aforward index, map, or the like. The storage location may indicate anadaptive layout configuration of the data structure on the array 115which, as disclosed herein, may include, but is not limited to: ahorizontal configuration, a vertical configuration, a hybrid,independent channel configuration, a vertical stripe configuration, orthe like.

Step 1130 may comprise reading the data from the determined storagelocations and/or in accordance with the determined data structureconfiguration. The read operation may comprise reading data from one ormore independent columns 118 comprising the array 115 (e.g., readingdata from one or more solid-state storage elements 116A-Y), as disclosedherein. Step 1130 may comprise providing columns 118 of the array 115with respective physical addresses (as determined at step 1120). Thephysical address may be the same (or equivalent) for each of thesolid-state storage elements 116A-Y (e.g., in a horizontal dataarrangement). Alternatively, the physical addresses may differ (e.g.,for a vertical, hybrid, independent channel, and/or certain verticalstripe configurations). Step 1130 may incur a read latency Tr, asdescribed above.

Step 1130 may further comprise streaming the ECC codewords from readbuffer(s) of the array into a adaptive storage module 113. Streaming thedata structures may comprise streaming sufficient data to reconstruct adata structure, such as a plurality of ECC codewords 620 comprising oneor more packets comprising the requested data. Each cycle of the bus 127may be configured to transfer a single byte from each column 118 of thearray. The number of bus cycles needed to transfer the requested ECCcodewords may depend on the arrangement of the data: data arrangedhorizontally may require ten (10) cycles to transfer a 240 byte ECCcodeword from 24 columns 118; data arranged vertically may require twohundred forty (240) cycles to transfer the same 240 byte ECC codewordfrom a single column 118; data arranged in a hybrid, independent channelarrangement may require 240/N cycles, where N is the number ofindependent, horizontal columns in the arrangement; and data arranged invertical stripes may require 240 cycles. In the vertical, hybrid,independent channel, and vertical stripe configurations, however,multiple ECC codewords may be streamed concurrently.

Step 1140 may comprise reconstructing the requested data by use of theadaptive storage module 130 (e.g., an adaptive read module 247). Step1140 may comprise buffering data read from the array 115, reordering thedata, stripping padding data corresponding to OOS columns 118 (if any),and so on as disclosed herein. Step 1140 may further comprise performingECC error detection and/or on ECC codewords comprising the data packet,by use of the ECC read module 245. ECC processing may further compriseverifying relational information associated with the ECC codewords, suchas a watermark on the ECC codewords, which may be derived from one ormore logical identifiers associated with the requested data. Step 1140may further comprise dewhitening the data packets, by use of the dewhitemodule 243 and depacketizing the data by use of the depacket module 241,as disclosed herein.

FIG. 12 is a flow diagram of another embodiment of a method 1200 foradaptive request scheduling. Step 1210 may comprise buffering storagerequests within a request buffer 136 of the storage module 130. Therequests may be ordered within the buffer 136.

Step 1220 may comprise determining storage location(s) corresponding tothe requests within the array 115, as disclosed above.

Step 1222 may comprise identifying storage requests that can be executedconcurrently (e.g., do not conflict). As disclosed above, a storagerequest conflict refers to storage requests that cannot be performedconcurrently within the same bank 119 and/or array 115. A storagerequest conflict may result from data structures associated with therequests overlapping within the array 115, such that the storagerequests pertain to data stored within one or more of the same columns118 within the array 115. Storage requests that can be executedconcurrently may refer to storage requests that pertain to data storedon different independent columns 118 of the array 115.

Step 1224 may comprise scheduling and/or combining the requests inaccordance with the concurrencies and/or conflicts identified at step1222. Step 1224 may comprise combining requests that can be performedconcurrently (e.g., do not conflict). Combining requests may comprisereordering requests within the buffer (e.g., changing the order of therequests within the buffer 136), as disclosed above, in order to combineconcurrent requests and/or avoid request conflicts. Accordingly, step1224 may comprise determining that the scheduled storage requests and/orstorage request combinations do not create data hazards, such asread-before-write hazards, write-before-read hazards, or the like. Insome embodiments, step 1224 may be limited to combining requests withoutchanging request ordering, to ensure that data hazards do not occur.

Step 1230 may comprise performing the scheduled requests, which maycomprise performing one or more combined read operations, as disclosedherein. Step 1240 may comprise reconstructing data of the requests byuse of a read module 241, adaptive read module 247, and so on, asdisclosed herein.

FIG. 13 is a flow diagram of one embodiment of a method 1300 foradaptive data reconstruction. Step 1320 may comprise detecting anuncorrectable error in an ECC codeword. Step 1320 may comprise detectingthe error by use of an ECC read module 245 of the read module 241. Step1320 may further comprise issuing an interrupt to a data reconstructionmodule 170, as disclosed herein. In some embodiments, step 1320 furthercomprises determining the source of the uncorrectable error, which mayinclude identifying the column 118 (e.g., particular solid-state storageelement 116A-Y) from which the uncorrectable data was read. Determiningthe source of the error may comprise referencing storage metadata 135,such as the logical-to-physical translation between the data andphysical storage location. Alternatively, identifying the source of theerror may comprise iterative parity substitution, as disclosed above.

Step 1330 may comprise performing a read operation to read ECC codewordswithin the same vertical stripe as the uncorrectable error, as disclosedabove in conjunction with FIG. 8. Alternatively, step 1330 may compriseperforming a read operation to read ECC codewords within other columns118 of a vertical data configuration and/or within other channels of ahybrid, independent channel configuration. Step 1330 may furthercomprise reading parity data corresponding to the vertical stripe,vertical data configuration, and/or hybrid, independent channelconfiguration, as disclosed herein.

Step 1340 may comprise correcting ECC codewords in the vertical stripeand/or other columns 118. Correcting the ECC codewords may compriseprocessing the ECC codewords using the ECC read module 245 and/orrelational verification module 647, as disclosed above. In someembodiments, step 1340 may be omitted, and the reconstruction step 1350may proceed without first decoding and/or correcting the ECC codewordsof the other columns 118.

Step 1350 may comprise reconstructing the uncorrectable data by use ofthe corrected ECC codewords and parity data. Step 1350 may comprise abyte-wise parity substitution operation between the corrected ECCcodewords and the parity data. In hybrid, independent channelconfigurations, step 1350 may further comprise determining the source ofthe uncorrectable error using iterative parity substitution within theindependent channel comprising the uncorrectable error. In a two-channelconfiguration, iterative parity substitution may comprise determiningwhich of the two channels is the source of the error. Other hybrid,independent channel configurations may involve additional iterations, inaccordance with the width of the channels.

Step 1350 may further comprise reconstructing the data by, inter alia,decoding the ECC codewords, including the reconstructed ECC codewords,dewhitening, and depacketizing the data, as disclosed above.

FIG. 14 is a flow diagram of one embodiment of a method 1400 fordetermining an adaptive storage configuration. Step 1420 may compriseacquiring profiling data 1420. Step 1420 may comprise accessingprofiling data generated by the storage module 130, stored, in a logstorage format, on the solid-state storage medium 110, and/or the like.The profiling data may include an ordered history of storage operationsand/or requests received at the storage module 130.

Step 1430 may comprise determining performance metrics of one of moreadaptive data storage configurations. Step 1430 may comprise replayingand/or simulating the history of storage requests in one or moredifferent adaptive storage configurations, which may include, but arenot limited to: a horizontal configuration, a vertical configuration, ahybrid, independent channel configuration, a vertical stripeconfiguration (of various vertical stripe depths), and/or the like. Step1430 may comprise determining the simulating the contents of variousportions of the solid-state storage array 115 under the differentadaptive data configurations, scheduling read operations according tothe adaptive layout (using the adaptive schedule module 114), and/or thelike. The performance metrics may be based on one or more of a desiredTOPS metric, a read time Ts, a stream time Ts, and so on, as disclosedabove.

Step 1440 may comprise determining an adaptive storage configuration.Step 1440 may comprise determining an optimal adaptive storageconfiguration based on the performance metrics and/or one or moreobjective functions. The determination of step 1440 may include variousmetrics and/or considerations, including the performance metricscalculated at step 1430, data reconstruction characteristics of variousdata layout configurations, and so on. Step 1440 may further compriseproviding an indication of the determined storage configuration (to auser, administrator, or other entity), automatically configuring theadaptive storage module 113 to operate in accordance with the determinedadaptive storage configuration, and/or the like.

The above description provides numerous specific details for a thoroughunderstanding of the embodiments described herein. However, those ofskill in the art will recognize that one or more of the specific detailsmay be omitted, or other methods, components, or materials may be used.In some cases, operations are not shown or described in detail.

Furthermore, the described features, operations, or characteristics maybe combined in any suitable manner in one or more embodiments. It willalso be readily understood that the order of the steps or actions of themethods described in connection with the embodiments disclosed may bechanged as would be apparent to those skilled in the art. Thus, anyorder in the drawings or Detailed Description is for illustrativepurposes only and is not meant to imply a required order, unlessspecified to require an order.

Embodiments may include various steps, which may be embodied inmachine-executable instructions to be executed by a general-purpose orspecial-purpose computer (or other electronic device). Alternatively,the steps may be performed by hardware components that include specificlogic for performing the steps, or by a combination of hardware,software, and/or firmware.

Embodiments may also be provided as a computer program product includinga computer-readable storage medium having stored instructions thereonthat may be used to program a computer (or other electronic device) toperform processes described herein. The computer-readable storage mediummay include, but is not limited to: hard drives, floppy diskettes,optical disks, CD-ROMs, DVD-ROMs, ROMs, RAMs, EPROMs, EEPROMs, magneticor optical cards, solid-state memory devices, or other types ofmedium/machine-readable medium suitable for storing electronicinstructions.

As used herein, a software module or component may include any type ofcomputer instruction or computer executable code located within a memorydevice and/or computer-readable storage medium. A software module may,for instance, comprise one or more physical or logical blocks ofcomputer instructions, which may be organized as a routine, program,object, component, data structure, etc., that perform one or more tasksor implements particular abstract data types.

In certain embodiments, a particular software module may comprisedisparate instructions stored in different locations of a memory device,which together implement the described functionality of the module.Indeed, a module may comprise a single instruction or many instructions,and may be distributed over several different code segments, amongdifferent programs, and across several memory devices. Some embodimentsmay be practiced in a distributed computing environment where tasks areperformed by a remote processing device linked through a communicationsnetwork. In a distributed computing environment, software modules may belocated in local and/or remote memory storage devices. In addition, databeing tied or rendered together in a database record may be resident inthe same memory device, or across several memory devices, and may belinked together in fields of a record in a database across a network.

It will be understood by those having skill in the art that many changesmay be made to the details of the above-described embodiments withoutdeparting from the underlying principles of the disclosure.

What is claimed is:
 1. A method, comprising: managing, via a storagemodule, storage operations for a solid-state storage array; queuingstorage requests for the solid-state storage array in an ordered requestbuffer; reordering the storage requests in the ordered request buffer,wherein the storage module comprises: a logical-to-physical translationlayer; and the ordered request buffer, wherein the ordered requestbuffer is configured to receive storage requests from one or more storeclients, and to buffer storage requests received via a bus; generating,via an error-correcting code write module, an error-correcting codecodeword comprising data for storage on the solid-state storage array,wherein the error-correcting code codeword is used to detect errors indata read from the solid-state storage array, correct errors in dataread from the solid-state storage array, or a combination thereof;generating, via a write module, data rows for storage within columns ofthe solid-state storage array, wherein each of the data rows comprisesdata of two or more different error-correcting code codewords;generating, via a parity module, respective parity data for each of thedata rows; and reconstructing, via a data reconstruction module, anuncorrectable error-correcting code codeword of the two or moredifferent error-correcting code codewords by accessing data rows and therespective parity data comprising the two or more differenterror-correcting code codewords.
 2. The method of claim 1, furthercomprising: detecting the uncorrectable error-correcting code codewordin response to a first read operation; recovering the uncorrectableerror-correcting code codeword by reading other error-correcting codecodewords within a vertical stripe with the uncorrectableerror-correcting code codewords in a second read operation; decoding theother error-correcting code codewords; and reconstructing theuncorrectable error-correcting code codewords using the decodederror-correcting code codewords and parity data of the vertical stripe.3. The method of claim 1, further comprising performing, via a groomingmodule, grooming operations.
 4. The method of claim 3, wherein thegrooming operations comprise reclaiming storage resources, erasure, wearleveling, refreshing data stored on the solid-state storage array, orsome combination thereof.
 5. The method of claim 1, wherein thesolid-state storage array comprises flash memory.
 6. The method of claim1, wherein the solid-state storage array comprises a plurality ofphysical storage cells configured for persistent data storage.
 7. Themethod of claim 6, wherein the plurality of physical storage cells isarranged in groups.
 8. The method of claim 7, wherein each group of thegroups comprises a page.
 9. The method of claim 7, wherein the groupsare partitioned into storage divisions.
 10. The method of claim 9,wherein each storage division of the storage divisions comprises anerase block.
 11. The method of claim 1, wherein the bus comprises aperipheral component interconnect express bus.
 12. The method of claim1, wherein the logical-to-physical translation layer comprisesany-to-any mappings.
 13. The method of claim 1, wherein the storagemodule is configured to actively scan the solid-state storage array toidentify sections of the solid-state storage array to be taken out ofservice.
 14. The method of claim 1, wherein the data reconstructionmodule is configured to reconstruct the uncorrectable error-correctingcode codeword based on a horizontal stripe configuration, a verticalstripe configuration, the parity, or some combination thereof.
 15. Themethod of claim 1, further comprising combining, via an adaptiveschedule module, two or more read operations into a combined readoperation, wherein the two or more read operations correspond toerror-correcting code codewords stored within different sets of storageelements of the solid-state storage array.
 16. An apparatus, comprising:a bus; a storage module configured to: manage storage operations for asolid-state storage array; queue storage requests for the solid-statestorage array in an ordered request buffer; and reorder the storagerequests in the ordered request buffer, wherein the storage modulecomprises: a logical-to-physical translation layer; and the orderedrequest buffer, wherein the ordered request buffer is configured toreceive storage requests from one or more store clients, and to bufferstorage requests received via the bus; an error-correcting code writemodule configured to generate an error-correcting code codewordcomprising data for storage on the solid-state storage array, whereinthe error-correcting code codeword is used to detect errors in data readfrom the solid-state storage array, correct errors in data read from thesolid-state storage array, or a combination thereof; a write moduleconfigured to generate data rows for storage within columns of thesolid-state storage array, wherein each of the data rows comprises dataof two or more different error-correcting code codewords; a paritymodule configured to generate respective parity data for each of thedata rows; and a data reconstruction module configured to reconstruct anuncorrectable error-correcting code codeword of the two or moredifferent error-correcting code codewords by accessing data rows and therespective parity data comprising the two or more differenterror-correcting code codewords.
 17. The apparatus of claim 16, furthercomprising: an error-correcting code read module configured to detectthe uncorrectable error-correcting code codeword in response to a firstread operation; and a data recovery module configured to: recover theuncorrectable error-correcting code codeword by reading othererror-correcting code codewords within a vertical stripe with theuncorrectable error-correcting code codewords in a second readoperation; decode the other error-correcting code codewords; andreconstruct the uncorrectable error-correcting code codewords using thedecoded error-correcting code codewords and parity data of the verticalstripe.
 18. The apparatus of claim 16, further comprising a groomermodule configured to perform grooming operations.
 19. The apparatus ofclaim 18, wherein the grooming operations comprise reclaiming storageresources, erasure, wear leveling, refreshing data stored on thesolid-state storage array, or some combination thereof.
 20. Theapparatus of claim 16, wherein the solid-state storage array comprisesflash memory.
 21. The apparatus of claim 16, wherein the solid-statestorage array comprises a plurality of physical storage cells configuredfor persistent data storage.
 22. The apparatus of claim 21, wherein theplurality of physical storage cells is arranged in groups.
 23. Theapparatus of claim 22, wherein each group of the groups comprises apage.
 24. The apparatus of claim 22, wherein the groups are partitionedinto storage divisions.
 25. The apparatus of claim 24, wherein eachstorage division of the storage divisions comprises an erase block. 26.The apparatus of claim 16, wherein the bus comprises a peripheralcomponent interconnect express bus.
 27. The apparatus of claim 16,wherein the logical-to-physical translation layer comprises any-to-anymappings.
 28. The apparatus of claim 16, wherein the storage module isconfigured to actively scan the solid-state storage array to identifysections of the solid-state storage array to be taken out of service.29. The apparatus of claim 16, wherein the data reconstruction module isconfigured to reconstruct the uncorrectable error-correcting codecodeword based on a horizontal stripe configuration, a vertical stripeconfiguration, the parity, or some combination thereof.
 30. Theapparatus of claim 16, further comprising an adaptive schedule moduleconfigured to combine two or more read operations into a combined readoperation, wherein the two or more read operations correspond toerror-correcting code codewords stored within different sets of storageelements of the solid-state storage array.